| /* |
| * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.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 "SelectElement.h" |
| |
| #include "Attribute.h" |
| #include "Chrome.h" |
| #include "ChromeClient.h" |
| #include "Element.h" |
| #include "EventHandler.h" |
| #include "EventNames.h" |
| #include "FormDataList.h" |
| #include "Frame.h" |
| #include "HTMLFormElement.h" |
| #include "HTMLNames.h" |
| #include "HTMLSelectElement.h" |
| #include "KeyboardEvent.h" |
| #include "MouseEvent.h" |
| #include "OptionElement.h" |
| #include "OptionGroupElement.h" |
| #include "Page.h" |
| #include "RenderListBox.h" |
| #include "RenderMenuList.h" |
| #include "SpatialNavigation.h" |
| #include <wtf/Assertions.h> |
| #include <wtf/unicode/CharacterNames.h> |
| |
| #if ENABLE(WML) |
| #include "WMLNames.h" |
| #include "WMLSelectElement.h" |
| #endif |
| |
| // Configure platform-specific behavior when focused pop-up receives arrow/space/return keystroke. |
| // (PLATFORM(MAC) and PLATFORM(GTK) are always false in Chromium, hence the extra tests.) |
| #if PLATFORM(MAC) || (PLATFORM(CHROMIUM) && OS(DARWIN)) |
| #define ARROW_KEYS_POP_MENU 1 |
| #define SPACE_OR_RETURN_POP_MENU 0 |
| #elif PLATFORM(GTK) || (PLATFORM(CHROMIUM) && (OS(LINUX) || OS(FREEBSD))) |
| #define ARROW_KEYS_POP_MENU 0 |
| #define SPACE_OR_RETURN_POP_MENU 1 |
| #else |
| #define ARROW_KEYS_POP_MENU 0 |
| #define SPACE_OR_RETURN_POP_MENU 0 |
| #endif |
| |
| using std::min; |
| using std::max; |
| using namespace WTF; |
| using namespace Unicode; |
| |
| namespace WebCore { |
| |
| static const DOMTimeStamp typeAheadTimeout = 1000; |
| |
| enum SkipDirection { |
| SkipBackwards = -1, |
| SkipForwards = 1 |
| }; |
| |
| // Returns the 1st valid item |skip| items from |listIndex| in direction |direction| if there is one. |
| // Otherwise, it returns the valid item closest to that boundary which is past |listIndex| if there is one. |
| // Otherwise, it returns |listIndex|. |
| // Valid means that it is enabled and an option element. |
| static int nextValidIndex(const Vector<Element*>& listItems, int listIndex, SkipDirection direction, int skip) |
| { |
| ASSERT(direction == -1 || direction == 1); |
| int lastGoodIndex = listIndex; |
| int size = listItems.size(); |
| for (listIndex += direction; listIndex >= 0 && listIndex < size; listIndex += direction) { |
| --skip; |
| if (!listItems[listIndex]->disabled() && isOptionElement(listItems[listIndex])) { |
| lastGoodIndex = listIndex; |
| if (skip <= 0) |
| break; |
| } |
| } |
| return lastGoodIndex; |
| } |
| |
| static int nextSelectableListIndex(SelectElementData& data, Element* element, int startIndex) |
| { |
| return nextValidIndex(data.listItems(element), startIndex, SkipForwards, 1); |
| } |
| |
| static int previousSelectableListIndex(SelectElementData& data, Element* element, int startIndex) |
| { |
| if (startIndex == -1) |
| startIndex = data.listItems(element).size(); |
| return nextValidIndex(data.listItems(element), startIndex, SkipBackwards, 1); |
| } |
| |
| static int firstSelectableListIndex(SelectElementData& data, Element* element) |
| { |
| const Vector<Element*>& items = data.listItems(element); |
| int index = nextValidIndex(items, items.size(), SkipBackwards, INT_MAX); |
| if (static_cast<unsigned>(index) == items.size()) |
| return -1; |
| return index; |
| } |
| |
| static int lastSelectableListIndex(SelectElementData& data, Element* element) |
| { |
| return nextValidIndex(data.listItems(element), -1, SkipForwards, INT_MAX); |
| } |
| |
| // Returns the index of the next valid item one page away from |startIndex| in direction |direction|. |
| static int nextSelectableListIndexPageAway(SelectElementData& data, Element* element, int startIndex, SkipDirection direction) |
| { |
| const Vector<Element*>& items = data.listItems(element); |
| // Can't use data->size() because renderer forces a minimum size. |
| int pageSize = 0; |
| if (element->renderer()->isListBox()) |
| pageSize = toRenderListBox(element->renderer())->size() - 1; // -1 so we still show context |
| |
| // One page away, but not outside valid bounds. |
| // If there is a valid option item one page away, the index is chosen. |
| // If there is no exact one page away valid option, returns startIndex or the most far index. |
| int edgeIndex = (direction == SkipForwards) ? 0 : (items.size() - 1); |
| int skipAmount = pageSize + ((direction == SkipForwards) ? startIndex : (edgeIndex - startIndex)); |
| return nextValidIndex(items, edgeIndex, direction, skipAmount); |
| } |
| |
| void SelectElement::selectAll(SelectElementData& data, Element* element) |
| { |
| ASSERT(!data.usesMenuList()); |
| if (!element->renderer() || !data.multiple()) |
| return; |
| |
| // Save the selection so it can be compared to the new selectAll selection when dispatching change events |
| saveLastSelection(data, element); |
| |
| data.setActiveSelectionState(true); |
| setActiveSelectionAnchorIndex(data, element, nextSelectableListIndex(data, element, -1)); |
| setActiveSelectionEndIndex(data, previousSelectableListIndex(data, element, -1)); |
| |
| updateListBoxSelection(data, element, false); |
| listBoxOnChange(data, element); |
| } |
| |
| void SelectElement::saveLastSelection(SelectElementData& data, Element* element) |
| { |
| if (data.usesMenuList()) { |
| data.setLastOnChangeIndex(selectedIndex(data, element)); |
| return; |
| } |
| |
| Vector<bool>& lastOnChangeSelection = data.lastOnChangeSelection(); |
| lastOnChangeSelection.clear(); |
| |
| const Vector<Element*>& items = data.listItems(element); |
| for (unsigned i = 0; i < items.size(); ++i) { |
| OptionElement* optionElement = toOptionElement(items[i]); |
| lastOnChangeSelection.append(optionElement && optionElement->selected()); |
| } |
| } |
| |
| void SelectElement::setActiveSelectionAnchorIndex(SelectElementData& data, Element* element, int index) |
| { |
| data.setActiveSelectionAnchorIndex(index); |
| |
| // Cache the selection state so we can restore the old selection as the new selection pivots around this anchor index |
| Vector<bool>& cachedStateForActiveSelection = data.cachedStateForActiveSelection(); |
| cachedStateForActiveSelection.clear(); |
| |
| const Vector<Element*>& items = data.listItems(element); |
| for (unsigned i = 0; i < items.size(); ++i) { |
| OptionElement* optionElement = toOptionElement(items[i]); |
| cachedStateForActiveSelection.append(optionElement && optionElement->selected()); |
| } |
| } |
| |
| void SelectElement::setActiveSelectionEndIndex(SelectElementData& data, int index) |
| { |
| data.setActiveSelectionEndIndex(index); |
| } |
| |
| void SelectElement::updateListBoxSelection(SelectElementData& data, Element* element, bool deselectOtherOptions) |
| { |
| ASSERT(element->renderer() && (element->renderer()->isListBox() || data.multiple())); |
| ASSERT(!data.listItems(element).size() || data.activeSelectionAnchorIndex() >= 0); |
| |
| unsigned start = min(data.activeSelectionAnchorIndex(), data.activeSelectionEndIndex()); |
| unsigned end = max(data.activeSelectionAnchorIndex(), data.activeSelectionEndIndex()); |
| Vector<bool>& cachedStateForActiveSelection = data.cachedStateForActiveSelection(); |
| |
| const Vector<Element*>& items = data.listItems(element); |
| for (unsigned i = 0; i < items.size(); ++i) { |
| OptionElement* optionElement = toOptionElement(items[i]); |
| if (!optionElement || items[i]->disabled()) |
| continue; |
| |
| if (i >= start && i <= end) |
| optionElement->setSelectedState(data.activeSelectionState()); |
| else if (deselectOtherOptions || i >= cachedStateForActiveSelection.size()) |
| optionElement->setSelectedState(false); |
| else |
| optionElement->setSelectedState(cachedStateForActiveSelection[i]); |
| } |
| |
| toSelectElement(element)->updateValidity(); |
| scrollToSelection(data, element); |
| } |
| |
| void SelectElement::listBoxOnChange(SelectElementData& data, Element* element) |
| { |
| ASSERT(!data.usesMenuList() || data.multiple()); |
| |
| Vector<bool>& lastOnChangeSelection = data.lastOnChangeSelection(); |
| const Vector<Element*>& items = data.listItems(element); |
| |
| // If the cached selection list is empty, or the size has changed, then fire dispatchFormControlChangeEvent, and return early. |
| if (lastOnChangeSelection.isEmpty() || lastOnChangeSelection.size() != items.size()) { |
| element->dispatchFormControlChangeEvent(); |
| return; |
| } |
| |
| // Update lastOnChangeSelection and fire dispatchFormControlChangeEvent |
| bool fireOnChange = false; |
| for (unsigned i = 0; i < items.size(); ++i) { |
| OptionElement* optionElement = toOptionElement(items[i]); |
| bool selected = optionElement && optionElement->selected(); |
| if (selected != lastOnChangeSelection[i]) |
| fireOnChange = true; |
| lastOnChangeSelection[i] = selected; |
| } |
| |
| if (fireOnChange) |
| element->dispatchFormControlChangeEvent(); |
| } |
| |
| void SelectElement::menuListOnChange(SelectElementData& data, Element* element) |
| { |
| ASSERT(data.usesMenuList()); |
| |
| int selected = selectedIndex(data, element); |
| if (data.lastOnChangeIndex() != selected && data.userDrivenChange()) { |
| data.setLastOnChangeIndex(selected); |
| data.setUserDrivenChange(false); |
| element->dispatchFormControlChangeEvent(); |
| } |
| } |
| |
| void SelectElement::scrollToSelection(SelectElementData& data, Element* element) |
| { |
| if (data.usesMenuList()) |
| return; |
| |
| if (RenderObject* renderer = element->renderer()) |
| toRenderListBox(renderer)->selectionChanged(); |
| } |
| |
| void SelectElement::setOptionsChangedOnRenderer(SelectElementData& data, Element* element) |
| { |
| if (RenderObject* renderer = element->renderer()) { |
| if (data.usesMenuList()) |
| toRenderMenuList(renderer)->setOptionsChanged(true); |
| else |
| toRenderListBox(renderer)->setOptionsChanged(true); |
| } |
| } |
| |
| void SelectElement::setRecalcListItems(SelectElementData& data, Element* element) |
| { |
| data.setShouldRecalcListItems(true); |
| data.setActiveSelectionAnchorIndex(-1); // Manual selection anchor is reset when manipulating the select programmatically. |
| setOptionsChangedOnRenderer(data, element); |
| element->setNeedsStyleRecalc(); |
| } |
| |
| void SelectElement::recalcListItems(SelectElementData& data, const Element* element, bool updateSelectedStates) |
| { |
| Vector<Element*>& listItems = data.rawListItems(); |
| listItems.clear(); |
| |
| data.setShouldRecalcListItems(false); |
| |
| OptionElement* foundSelected = 0; |
| for (Node* currentNode = element->firstChild(); currentNode;) { |
| if (!currentNode->isElementNode()) { |
| currentNode = currentNode->traverseNextSibling(element); |
| continue; |
| } |
| |
| Element* current = static_cast<Element*>(currentNode); |
| |
| // optgroup tags may not nest. However, both FireFox and IE will |
| // flatten the tree automatically, so we follow suit. |
| // (http://www.w3.org/TR/html401/interact/forms.html#h-17.6) |
| if (isOptionGroupElement(current)) { |
| listItems.append(current); |
| if (current->firstChild()) { |
| currentNode = current->firstChild(); |
| continue; |
| } |
| } |
| |
| if (OptionElement* optionElement = toOptionElement(current)) { |
| listItems.append(current); |
| |
| if (updateSelectedStates && !data.multiple()) { |
| if (!foundSelected && (data.size() <= 1 || optionElement->selected())) { |
| foundSelected = optionElement; |
| foundSelected->setSelectedState(true); |
| } else if (foundSelected && optionElement->selected()) { |
| foundSelected->setSelectedState(false); |
| foundSelected = optionElement; |
| } |
| } |
| } |
| |
| if (current->hasTagName(HTMLNames::hrTag)) |
| listItems.append(current); |
| |
| // In conforming HTML code, only <optgroup> and <option> will be found |
| // within a <select>. We call traverseNextSibling so that we only step |
| // into those tags that we choose to. For web-compat, we should cope |
| // with the case where odd tags like a <div> have been added but we |
| // handle this because such tags have already been removed from the |
| // <select>'s subtree at this point. |
| currentNode = currentNode->traverseNextSibling(element); |
| } |
| } |
| |
| int SelectElement::selectedIndex(const SelectElementData& data, const Element* element) |
| { |
| unsigned index = 0; |
| |
| // return the number of the first option selected |
| const Vector<Element*>& items = data.listItems(element); |
| for (size_t i = 0; i < items.size(); ++i) { |
| if (OptionElement* optionElement = toOptionElement(items[i])) { |
| if (optionElement->selected()) |
| return index; |
| ++index; |
| } |
| } |
| |
| return -1; |
| } |
| |
| void SelectElement::setSelectedIndex(SelectElementData& data, Element* element, int optionIndex, bool deselect, bool fireOnChangeNow, bool userDrivenChange) |
| { |
| if (optionIndex == -1 && !deselect && !data.multiple()) |
| optionIndex = nextSelectableListIndex(data, element, -1); |
| if (!data.multiple()) |
| deselect = true; |
| |
| const Vector<Element*>& items = data.listItems(element); |
| int listIndex = optionToListIndex(data, element, optionIndex); |
| |
| Element* excludeElement = 0; |
| if (OptionElement* optionElement = (listIndex >= 0 ? toOptionElement(items[listIndex]) : 0)) { |
| excludeElement = items[listIndex]; |
| if (data.activeSelectionAnchorIndex() < 0 || deselect) |
| setActiveSelectionAnchorIndex(data, element, listIndex); |
| if (data.activeSelectionEndIndex() < 0 || deselect) |
| setActiveSelectionEndIndex(data, listIndex); |
| optionElement->setSelectedState(true); |
| } |
| |
| if (deselect) |
| deselectItems(data, element, excludeElement); |
| |
| // For the menu list case, this is what makes the selected element appear. |
| if (RenderObject* renderer = element->renderer()) |
| renderer->updateFromElement(); |
| |
| scrollToSelection(data, element); |
| |
| // This only gets called with fireOnChangeNow for menu lists. |
| if (data.usesMenuList()) { |
| data.setUserDrivenChange(userDrivenChange); |
| if (fireOnChangeNow) |
| menuListOnChange(data, element); |
| RenderObject* renderer = element->renderer(); |
| if (renderer) { |
| if (data.usesMenuList()) |
| toRenderMenuList(renderer)->didSetSelectedIndex(); |
| else if (renderer->isListBox()) |
| toRenderListBox(renderer)->selectionChanged(); |
| } |
| } |
| |
| if (Frame* frame = element->document()->frame()) |
| frame->page()->chrome()->client()->formStateDidChange(element); |
| } |
| |
| int SelectElement::optionToListIndex(const SelectElementData& data, const Element* element, int optionIndex) |
| { |
| const Vector<Element*>& items = data.listItems(element); |
| int listSize = (int) items.size(); |
| if (optionIndex < 0 || optionIndex >= listSize) |
| return -1; |
| |
| int optionIndex2 = -1; |
| for (int listIndex = 0; listIndex < listSize; ++listIndex) { |
| if (isOptionElement(items[listIndex])) { |
| ++optionIndex2; |
| if (optionIndex2 == optionIndex) |
| return listIndex; |
| } |
| } |
| |
| return -1; |
| } |
| |
| int SelectElement::listToOptionIndex(const SelectElementData& data, const Element* element, int listIndex) |
| { |
| const Vector<Element*>& items = data.listItems(element); |
| if (listIndex < 0 || listIndex >= int(items.size()) || |
| !isOptionElement(items[listIndex])) |
| 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 (isOptionElement(items[i])) |
| ++optionIndex; |
| |
| return optionIndex; |
| } |
| |
| void SelectElement::dispatchFocusEvent(SelectElementData& data, Element* element) |
| { |
| // Save the selection so it can be compared to the new selection when dispatching change events during blur event dispatchal |
| if (data.usesMenuList()) |
| saveLastSelection(data, element); |
| } |
| |
| void SelectElement::dispatchBlurEvent(SelectElementData& data, Element* element) |
| { |
| // We only need to fire change events here for menu lists, because we fire change events for list boxes whenever the selection change is actually made. |
| // This matches other browsers' behavior. |
| if (data.usesMenuList()) |
| menuListOnChange(data, element); |
| } |
| |
| void SelectElement::deselectItems(SelectElementData& data, Element* element, Element* excludeElement) |
| { |
| const Vector<Element*>& items = data.listItems(element); |
| for (unsigned i = 0; i < items.size(); ++i) { |
| if (items[i] == excludeElement) |
| continue; |
| |
| if (OptionElement* optionElement = toOptionElement(items[i])) |
| optionElement->setSelectedState(false); |
| } |
| } |
| |
| bool SelectElement::saveFormControlState(const SelectElementData& data, const Element* element, String& value) |
| { |
| const Vector<Element*>& items = data.listItems(element); |
| int length = items.size(); |
| |
| // FIXME: Change this code to use the new StringImpl::createUninitialized code path. |
| Vector<char, 1024> characters(length); |
| for (int i = 0; i < length; ++i) { |
| OptionElement* optionElement = toOptionElement(items[i]); |
| bool selected = optionElement && optionElement->selected(); |
| characters[i] = selected ? 'X' : '.'; |
| } |
| |
| value = String(characters.data(), length); |
| return true; |
| } |
| |
| void SelectElement::restoreFormControlState(SelectElementData& data, Element* element, const String& state) |
| { |
| recalcListItems(data, element); |
| |
| const Vector<Element*>& items = data.listItems(element); |
| int length = items.size(); |
| |
| for (int i = 0; i < length; ++i) { |
| if (OptionElement* optionElement = toOptionElement(items[i])) |
| optionElement->setSelectedState(state[i] == 'X'); |
| } |
| |
| setOptionsChangedOnRenderer(data, element); |
| } |
| |
| void SelectElement::parseMultipleAttribute(SelectElementData& data, Element* element, Attribute* attribute) |
| { |
| bool oldUsesMenuList = data.usesMenuList(); |
| data.setMultiple(!attribute->isNull()); |
| toSelectElement(element)->updateValidity(); |
| if (oldUsesMenuList != data.usesMenuList() && element->attached()) { |
| element->detach(); |
| element->attach(); |
| } |
| } |
| |
| bool SelectElement::appendFormData(SelectElementData& data, Element* element, FormDataList& list) |
| { |
| const AtomicString& name = element->formControlName(); |
| if (name.isEmpty()) |
| return false; |
| |
| bool successful = false; |
| const Vector<Element*>& items = data.listItems(element); |
| |
| for (unsigned i = 0; i < items.size(); ++i) { |
| OptionElement* optionElement = toOptionElement(items[i]); |
| if (optionElement && optionElement->selected() && !optionElement->disabled()) { |
| list.appendData(name, optionElement->value()); |
| successful = true; |
| } |
| } |
| |
| // It's possible that this is a menulist with multiple options and nothing |
| // will be submitted (!successful). We won't send a unselected non-disabled |
| // option as fallback. This behavior matches to other browsers. |
| return successful; |
| } |
| |
| void SelectElement::reset(SelectElementData& data, Element* element) |
| { |
| OptionElement* firstOption = 0; |
| OptionElement* selectedOption = 0; |
| |
| const Vector<Element*>& items = data.listItems(element); |
| for (unsigned i = 0; i < items.size(); ++i) { |
| OptionElement* optionElement = toOptionElement(items[i]); |
| if (!optionElement) |
| continue; |
| |
| if (items[i]->fastHasAttribute(HTMLNames::selectedAttr)) { |
| if (selectedOption && !data.multiple()) |
| selectedOption->setSelectedState(false); |
| optionElement->setSelectedState(true); |
| selectedOption = optionElement; |
| } else |
| optionElement->setSelectedState(false); |
| |
| if (!firstOption) |
| firstOption = optionElement; |
| } |
| |
| if (!selectedOption && firstOption && !data.multiple() && data.size() <= 1) |
| firstOption->setSelectedState(true); |
| |
| setOptionsChangedOnRenderer(data, element); |
| element->setNeedsStyleRecalc(); |
| } |
| |
| void SelectElement::menuListDefaultEventHandler(SelectElementData& data, Element* element, Event* event, HTMLFormElement* htmlForm) |
| { |
| if (event->type() == eventNames().keydownEvent) { |
| if (!element->renderer() || !event->isKeyboardEvent()) |
| return; |
| |
| const String& keyIdentifier = static_cast<KeyboardEvent*>(event)->keyIdentifier(); |
| bool handled = false; |
| |
| #if ARROW_KEYS_POP_MENU |
| if (!isSpatialNavigationEnabled(element->document()->frame())) { |
| if (keyIdentifier == "Down" || keyIdentifier == "Up") { |
| element->focus(); |
| |
| if (!element->renderer()) // Calling focus() may cause us to lose our renderer, in which case do not want to handle the event. |
| return; |
| |
| // Save the selection so it can be compared to the new selection when dispatching change events during setSelectedIndex, |
| // which gets called from RenderMenuList::valueChanged, which gets called after the user makes a selection from the menu. |
| saveLastSelection(data, element); |
| if (RenderMenuList* menuList = toRenderMenuList(element->renderer())) |
| menuList->showPopup(); |
| |
| event->setDefaultHandled(); |
| } |
| return; |
| } |
| #endif |
| // When using spatial navigation, we want to be able to navigate away from the select element |
| // when the user hits any of the arrow keys, instead of changing the selection. |
| if (isSpatialNavigationEnabled(element->document()->frame())) |
| if (!data.activeSelectionState()) |
| return; |
| |
| UNUSED_PARAM(htmlForm); |
| const Vector<Element*>& listItems = data.listItems(element); |
| |
| int listIndex = optionToListIndex(data, element, selectedIndex(data, element)); |
| if (keyIdentifier == "Down" || keyIdentifier == "Right") { |
| listIndex = nextValidIndex(listItems, listIndex, SkipForwards, 1); |
| handled = true; |
| } else if (keyIdentifier == "Up" || keyIdentifier == "Left") { |
| listIndex = nextValidIndex(listItems, listIndex, SkipBackwards, 1); |
| handled = true; |
| } else if (keyIdentifier == "PageDown") { |
| listIndex = nextValidIndex(listItems, listIndex, SkipForwards, 3); |
| handled = true; |
| } else if (keyIdentifier == "PageUp") { |
| listIndex = nextValidIndex(listItems, listIndex, SkipBackwards, 3); |
| handled = true; |
| } else if (keyIdentifier == "Home") { |
| listIndex = nextValidIndex(listItems, -1, SkipForwards, 1); |
| handled = true; |
| } else if (keyIdentifier == "End") { |
| listIndex = nextValidIndex(listItems, listItems.size(), SkipBackwards, 1); |
| handled = true; |
| } |
| |
| if (handled && listIndex >= 0 && static_cast<unsigned>(listIndex) < listItems.size()) |
| setSelectedIndex(data, element, listToOptionIndex(data, element, listIndex)); |
| |
| if (handled) |
| event->setDefaultHandled(); |
| } |
| |
| // Use key press event here since sending simulated mouse events |
| // on key down blocks the proper sending of the key press event. |
| if (event->type() == eventNames().keypressEvent) { |
| if (!element->renderer() || !event->isKeyboardEvent()) |
| return; |
| |
| int keyCode = static_cast<KeyboardEvent*>(event)->keyCode(); |
| bool handled = false; |
| |
| if (keyCode == ' ' && isSpatialNavigationEnabled(element->document()->frame())) { |
| // Use space to toggle arrow key handling for selection change or spatial navigation. |
| data.setActiveSelectionState(!data.activeSelectionState()); |
| event->setDefaultHandled(); |
| return; |
| } |
| |
| #if SPACE_OR_RETURN_POP_MENU |
| if (keyCode == ' ' || keyCode == '\r') { |
| element->focus(); |
| |
| if (!element->renderer()) // Calling focus() may cause us to lose our renderer, in which case do not want to handle the event. |
| return; |
| |
| // Save the selection so it can be compared to the new selection when dispatching change events during setSelectedIndex, |
| // which gets called from RenderMenuList::valueChanged, which gets called after the user makes a selection from the menu. |
| saveLastSelection(data, element); |
| if (RenderMenuList* menuList = toRenderMenuList(element->renderer())) |
| menuList->showPopup(); |
| handled = true; |
| } |
| #elif ARROW_KEYS_POP_MENU |
| if (keyCode == ' ') { |
| element->focus(); |
| |
| if (!element->renderer()) // Calling focus() may cause us to lose our renderer, in which case do not want to handle the event. |
| return; |
| |
| // Save the selection so it can be compared to the new selection when dispatching change events during setSelectedIndex, |
| // which gets called from RenderMenuList::valueChanged, which gets called after the user makes a selection from the menu. |
| saveLastSelection(data, element); |
| if (RenderMenuList* menuList = toRenderMenuList(element->renderer())) |
| menuList->showPopup(); |
| handled = true; |
| } else if (keyCode == '\r') { |
| if (htmlForm) |
| htmlForm->submitImplicitly(event, false); |
| menuListOnChange(data, element); |
| handled = true; |
| } |
| #else |
| int listIndex = optionToListIndex(data, element, selectedIndex(data, element)); |
| if (keyCode == '\r') { |
| // listIndex should already be selected, but this will fire the onchange handler. |
| setSelectedIndex(data, element, listToOptionIndex(data, element, listIndex), true, true); |
| handled = true; |
| } |
| #endif |
| if (handled) |
| event->setDefaultHandled(); |
| } |
| |
| if (event->type() == eventNames().mousedownEvent && event->isMouseEvent() && static_cast<MouseEvent*>(event)->button() == LeftButton) { |
| element->focus(); |
| if (element->renderer() && element->renderer()->isMenuList()) { |
| if (RenderMenuList* menuList = toRenderMenuList(element->renderer())) { |
| if (menuList->popupIsVisible()) |
| menuList->hidePopup(); |
| else { |
| // Save the selection so it can be compared to the new selection when we call onChange during setSelectedIndex, |
| // which gets called from RenderMenuList::valueChanged, which gets called after the user makes a selection from the menu. |
| saveLastSelection(data, element); |
| menuList->showPopup(); |
| } |
| } |
| } |
| event->setDefaultHandled(); |
| } |
| } |
| |
| void SelectElement::updateSelectedState(SelectElementData& data, Element* element, int listIndex, |
| bool multi, bool shift) |
| { |
| ASSERT(listIndex >= 0); |
| |
| // Save the selection so it can be compared to the new selection when dispatching change events during mouseup, or after autoscroll finishes. |
| saveLastSelection(data, element); |
| |
| data.setActiveSelectionState(true); |
| |
| bool shiftSelect = data.multiple() && shift; |
| bool multiSelect = data.multiple() && multi && !shift; |
| |
| Element* clickedElement = data.listItems(element)[listIndex]; |
| OptionElement* option = toOptionElement(clickedElement); |
| if (option) { |
| // Keep track of whether an active selection (like during drag selection), should select or deselect |
| if (option->selected() && multi) |
| data.setActiveSelectionState(false); |
| |
| if (!data.activeSelectionState()) |
| option->setSelectedState(false); |
| } |
| |
| // If we're not in any special multiple selection mode, then deselect all other items, excluding the clicked option. |
| // If no option was clicked, then this will deselect all items in the list. |
| if (!shiftSelect && !multiSelect) |
| deselectItems(data, element, clickedElement); |
| |
| // If the anchor hasn't been set, and we're doing a single selection or a shift selection, then initialize the anchor to the first selected index. |
| if (data.activeSelectionAnchorIndex() < 0 && !multiSelect) |
| setActiveSelectionAnchorIndex(data, element, selectedIndex(data, element)); |
| |
| // Set the selection state of the clicked option |
| if (option && !clickedElement->disabled()) |
| option->setSelectedState(true); |
| |
| // If there was no selectedIndex() for the previous initialization, or |
| // If we're doing a single selection, or a multiple selection (using cmd or ctrl), then initialize the anchor index to the listIndex that just got clicked. |
| if (data.activeSelectionAnchorIndex() < 0 || !shiftSelect) |
| setActiveSelectionAnchorIndex(data, element, listIndex); |
| |
| setActiveSelectionEndIndex(data, listIndex); |
| updateListBoxSelection(data, element, !multiSelect); |
| } |
| |
| void SelectElement::listBoxDefaultEventHandler(SelectElementData& data, Element* element, Event* event, HTMLFormElement* htmlForm) |
| { |
| const Vector<Element*>& listItems = data.listItems(element); |
| |
| if (event->type() == eventNames().mousedownEvent && event->isMouseEvent() && static_cast<MouseEvent*>(event)->button() == LeftButton) { |
| element->focus(); |
| |
| if (!element->renderer()) // Calling focus() may cause us to lose our renderer, in which case do not want to handle the event. |
| return; |
| |
| // Convert to coords relative to the list box if needed. |
| MouseEvent* mouseEvent = static_cast<MouseEvent*>(event); |
| IntPoint localOffset = roundedIntPoint(element->renderer()->absoluteToLocal(mouseEvent->absoluteLocation(), false, true)); |
| int listIndex = toRenderListBox(element->renderer())->listIndexAtOffset(localOffset.x(), localOffset.y()); |
| if (listIndex >= 0) { |
| #if PLATFORM(MAC) || (PLATFORM(CHROMIUM) && OS(DARWIN)) |
| updateSelectedState(data, element, listIndex, mouseEvent->metaKey(), mouseEvent->shiftKey()); |
| #else |
| updateSelectedState(data, element, listIndex, mouseEvent->ctrlKey(), mouseEvent->shiftKey()); |
| #endif |
| if (Frame* frame = element->document()->frame()) |
| frame->eventHandler()->setMouseDownMayStartAutoscroll(); |
| |
| event->setDefaultHandled(); |
| } |
| } else if (event->type() == eventNames().mouseupEvent && event->isMouseEvent() && static_cast<MouseEvent*>(event)->button() == LeftButton && element->document()->frame()->eventHandler()->autoscrollRenderer() != element->renderer()) { |
| // This makes sure we fire dispatchFormControlChangeEvent for a single click. For drag selection, onChange will fire when the autoscroll timer stops. |
| listBoxOnChange(data, element); |
| } 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 (data.activeSelectionEndIndex() < 0) { |
| // Initialize the end index |
| if (keyIdentifier == "Down" || keyIdentifier == "PageDown") { |
| int startIndex = lastSelectedListIndex(data, element); |
| handled = true; |
| if (keyIdentifier == "Down") |
| endIndex = nextSelectableListIndex(data, element, startIndex); |
| else |
| endIndex = nextSelectableListIndexPageAway(data, element, startIndex, SkipForwards); |
| } else if (keyIdentifier == "Up" || keyIdentifier == "PageUp") { |
| int startIndex = optionToListIndex(data, element, selectedIndex(data, element)); |
| handled = true; |
| if (keyIdentifier == "Up") |
| endIndex = previousSelectableListIndex(data, element, startIndex); |
| else |
| endIndex = nextSelectableListIndexPageAway(data, element, startIndex, SkipBackwards); |
| } |
| } else { |
| // Set the end index based on the current end index |
| if (keyIdentifier == "Down") { |
| endIndex = nextSelectableListIndex(data, element, data.activeSelectionEndIndex()); |
| handled = true; |
| } else if (keyIdentifier == "Up") { |
| endIndex = previousSelectableListIndex(data, element, data.activeSelectionEndIndex()); |
| handled = true; |
| } else if (keyIdentifier == "PageDown") { |
| endIndex = nextSelectableListIndexPageAway(data, element, data.activeSelectionEndIndex(), SkipForwards); |
| handled = true; |
| } else if (keyIdentifier == "PageUp") { |
| endIndex = nextSelectableListIndexPageAway(data, element, data.activeSelectionEndIndex(), SkipBackwards); |
| handled = true; |
| } |
| } |
| if (keyIdentifier == "Home") { |
| endIndex = firstSelectableListIndex(data, element); |
| handled = true; |
| } else if (keyIdentifier == "End") { |
| endIndex = lastSelectableListIndex(data, element); |
| handled = true; |
| } |
| |
| if (isSpatialNavigationEnabled(element->document()->frame())) |
| // Check if the selection moves to the boundary. |
| if (keyIdentifier == "Left" || keyIdentifier == "Right" || ((keyIdentifier == "Down" || keyIdentifier == "Up") && endIndex == data.activeSelectionEndIndex())) |
| return; |
| |
| if (endIndex >= 0 && handled) { |
| // Save the selection so it can be compared to the new selection when dispatching change events immediately after making the new selection. |
| saveLastSelection(data, element); |
| |
| ASSERT_UNUSED(listItems, !listItems.size() || (endIndex >= 0 && static_cast<unsigned>(endIndex) < listItems.size())); |
| setActiveSelectionEndIndex(data, endIndex); |
| |
| bool selectNewItem = !data.multiple() || static_cast<KeyboardEvent*>(event)->shiftKey() || !isSpatialNavigationEnabled(element->document()->frame()); |
| if (selectNewItem) |
| data.setActiveSelectionState(true); |
| // If the anchor is unitialized, or if we're going to deselect all other options, then set the anchor index equal to the end index. |
| bool deselectOthers = !data.multiple() || (!static_cast<KeyboardEvent*>(event)->shiftKey() && selectNewItem); |
| if (data.activeSelectionAnchorIndex() < 0 || deselectOthers) { |
| if (deselectOthers) |
| deselectItems(data, element); |
| setActiveSelectionAnchorIndex(data, element, data.activeSelectionEndIndex()); |
| } |
| |
| toRenderListBox(element->renderer())->scrollToRevealElementAtListIndex(endIndex); |
| if (selectNewItem) { |
| updateListBoxSelection(data, element, deselectOthers); |
| listBoxOnChange(data, element); |
| } else |
| scrollToSelection(data, element); |
| |
| event->setDefaultHandled(); |
| } |
| } else if (event->type() == eventNames().keypressEvent) { |
| if (!event->isKeyboardEvent()) |
| return; |
| int keyCode = static_cast<KeyboardEvent*>(event)->keyCode(); |
| |
| if (keyCode == '\r') { |
| if (htmlForm) |
| htmlForm->submitImplicitly(event, false); |
| event->setDefaultHandled(); |
| } else if (data.multiple() && keyCode == ' ' && isSpatialNavigationEnabled(element->document()->frame())) { |
| // Use space to toggle selection change. |
| data.setActiveSelectionState(!data.activeSelectionState()); |
| updateSelectedState(data, element, listToOptionIndex(data, element, data.activeSelectionEndIndex()), true /*multi*/, false /*shift*/); |
| listBoxOnChange(data, element); |
| event->setDefaultHandled(); |
| } |
| } |
| } |
| |
| void SelectElement::defaultEventHandler(SelectElementData& data, Element* element, Event* event, HTMLFormElement* htmlForm) |
| { |
| if (!element->renderer()) |
| return; |
| |
| if (data.usesMenuList()) |
| menuListDefaultEventHandler(data, element, event, htmlForm); |
| else |
| listBoxDefaultEventHandler(data, element, event, htmlForm); |
| |
| 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(data, element, keyboardEvent); |
| event->setDefaultHandled(); |
| return; |
| } |
| } |
| } |
| |
| int SelectElement::lastSelectedListIndex(const SelectElementData& data, const Element* element) |
| { |
| // return the number of the last option selected |
| unsigned index = 0; |
| bool found = false; |
| const Vector<Element*>& items = data.listItems(element); |
| for (size_t i = 0; i < items.size(); ++i) { |
| if (OptionElement* optionElement = toOptionElement(items[i])) { |
| if (optionElement->selected()) { |
| index = i; |
| found = true; |
| } |
| } |
| } |
| |
| return found ? (int) index : -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 SelectElement::typeAheadFind(SelectElementData& data, Element* element, KeyboardEvent* event) |
| { |
| if (event->timeStamp() < data.lastCharTime()) |
| return; |
| |
| DOMTimeStamp delta = event->timeStamp() - data.lastCharTime(); |
| data.setLastCharTime(event->timeStamp()); |
| |
| UChar c = event->charCode(); |
| |
| String prefix; |
| int searchStartOffset = 1; |
| if (delta > typeAheadTimeout) { |
| prefix = String(&c, 1); |
| data.setTypedString(prefix); |
| data.setRepeatingChar(c); |
| } else { |
| data.typedString().append(c); |
| |
| if (c == data.repeatingChar()) |
| // The user is likely trying to cycle through all the items starting with this character, so just search on the character |
| prefix = String(&c, 1); |
| else { |
| data.setRepeatingChar(0); |
| prefix = data.typedString(); |
| searchStartOffset = 0; |
| } |
| } |
| |
| const Vector<Element*>& items = data.listItems(element); |
| int itemCount = items.size(); |
| if (itemCount < 1) |
| return; |
| |
| int selected = selectedIndex(data, element); |
| int index = (optionToListIndex(data, element, selected >= 0 ? selected : 0) + searchStartOffset) % itemCount; |
| ASSERT(index >= 0); |
| |
| // Compute a case-folded copy of the prefix string before beginning the search for |
| // a matching element. This code uses foldCase to work around the fact that |
| // String::startWith does not fold non-ASCII characters. This code can be changed |
| // to use startWith once that is fixed. |
| String prefixWithCaseFolded(prefix.foldCase()); |
| for (int i = 0; i < itemCount; ++i, index = (index + 1) % itemCount) { |
| OptionElement* optionElement = toOptionElement(items[index]); |
| if (!optionElement || items[index]->disabled()) |
| continue; |
| |
| // Fold the option string and check if its prefix is equal to the folded prefix. |
| String text = optionElement->textIndentedToRespectGroupLabel(); |
| if (stripLeadingWhiteSpace(text).foldCase().startsWith(prefixWithCaseFolded)) { |
| setSelectedIndex(data, element, listToOptionIndex(data, element, index)); |
| if (!data.usesMenuList()) |
| listBoxOnChange(data, element); |
| |
| setOptionsChangedOnRenderer(data, element); |
| element->setNeedsStyleRecalc(); |
| return; |
| } |
| } |
| } |
| |
| void SelectElement::insertedIntoTree(SelectElementData& data, Element* element) |
| { |
| // When the element is created during document parsing, it won't have any items yet - but for innerHTML |
| // and related methods, this method is called after the whole subtree is constructed. |
| recalcListItems(data, element, true); |
| } |
| |
| void SelectElement::accessKeySetSelectedIndex(SelectElementData& data, Element* element, int index) |
| { |
| // first bring into focus the list box |
| if (!element->focused()) |
| element->accessKeyAction(false); |
| |
| // if this index is already selected, unselect. otherwise update the selected index |
| const Vector<Element*>& items = data.listItems(element); |
| int listIndex = optionToListIndex(data, element, index); |
| if (OptionElement* optionElement = (listIndex >= 0 ? toOptionElement(items[listIndex]) : 0)) { |
| if (optionElement->selected()) |
| optionElement->setSelectedState(false); |
| else |
| setSelectedIndex(data, element, index, false, true); |
| } |
| |
| if (data.usesMenuList()) |
| menuListOnChange(data, element); |
| else |
| listBoxOnChange(data, element); |
| |
| scrollToSelection(data, element); |
| } |
| |
| unsigned SelectElement::optionCount(const SelectElementData& data, const Element* element) |
| { |
| unsigned options = 0; |
| |
| const Vector<Element*>& items = data.listItems(element); |
| for (unsigned i = 0; i < items.size(); ++i) { |
| if (isOptionElement(items[i])) |
| ++options; |
| } |
| |
| return options; |
| } |
| |
| // SelectElementData |
| SelectElementData::SelectElementData() |
| : m_multiple(false) |
| , m_size(0) |
| , m_lastOnChangeIndex(-1) |
| , m_activeSelectionState(false) |
| , m_activeSelectionAnchorIndex(-1) |
| , m_activeSelectionEndIndex(-1) |
| , m_recalcListItems(false) |
| , m_repeatingChar(0) |
| , m_lastCharTime(0) |
| { |
| } |
| |
| SelectElementData::~SelectElementData() |
| { |
| } |
| |
| void SelectElementData::checkListItems(const Element* element) const |
| { |
| #if !ASSERT_DISABLED |
| Vector<Element*> items = m_listItems; |
| SelectElement::recalcListItems(*const_cast<SelectElementData*>(this), element, false); |
| ASSERT(items == m_listItems); |
| #else |
| UNUSED_PARAM(element); |
| #endif |
| } |
| |
| Vector<Element*>& SelectElementData::listItems(const Element* element) |
| { |
| if (m_recalcListItems) |
| SelectElement::recalcListItems(*this, element); |
| else |
| checkListItems(element); |
| |
| return m_listItems; |
| } |
| |
| const Vector<Element*>& SelectElementData::listItems(const Element* element) const |
| { |
| if (m_recalcListItems) |
| SelectElement::recalcListItems(*const_cast<SelectElementData*>(this), element); |
| else |
| checkListItems(element); |
| |
| return m_listItems; |
| } |
| |
| SelectElement* toSelectElement(Element* element) |
| { |
| if (element->isHTMLElement() && element->hasTagName(HTMLNames::selectTag)) |
| return static_cast<HTMLSelectElement*>(element); |
| |
| #if ENABLE(WML) |
| if (element->isWMLElement() && element->hasTagName(WMLNames::selectTag)) |
| return static_cast<WMLSelectElement*>(element); |
| #endif |
| |
| return 0; |
| } |
| |
| } |
