Implement select element list box with shadow DOM.

Source/WebCore/html/HTMLSelectElement.cpp

 /*
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * 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, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
@@ skipping 33 matching lines @@
 #include "HTMLOptionsCollection.h"
 #include "KeyboardEvent.h"
 #include "LocalizedStrings.h"
 #include "MouseEvent.h"
 #include "NodeRenderingContext.h"
 #include "NodeTraversal.h"
 #include "Page.h"
 #include "RenderListBox.h"
 #include "RenderMenuList.h"
 #include "RenderTheme.h"
+ #include "StyleResolver.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 {
 
@@ skipping 603 matching lines @@
         m_lastOnChangeIndex = selected;
         m_isProcessingUserDrivenChange = false;
         dispatchFormControlChangeEvent();
     }
 }
 
 void HTMLSelectElement::scrollToSelection()
 {
     if (usesMenuList())
         return;
-
-    if (RenderObject* renderer = this->renderer())
-        toRenderListBox(renderer)->selectionChanged();
+    int listIndex = activeSelectionEndListIndex();
+    const Vector<HTMLElement*>& items = listItems();
+    int listSize = static_cast<int>(items.size());
+    if (listIndex < 0 || listIndex >= listSize)
+        return;
+    Element* option = listItems()[listIndex];
+    option->scrollIntoViewIfNeeded(false);
 }
 
 void HTMLSelectElement::setOptionsChangedOnRenderer()
 {
     if (RenderObject* renderer = this->renderer()) {
         if (usesMenuList())
             toRenderMenuList(renderer)->setOptionsChanged(true);
-        else
-            toRenderListBox(renderer)->setOptionsChanged(true);
+//        else
+//            scrollToSelection();
     }
 }
 
 const Vector<HTMLElement*>& HTMLSelectElement::listItems() const
 {
     if (m_shouldRecalcListItems)
         recalcListItems();
     else {
 #if !ASSERT_DISABLED
         Vector<HTMLElement*> items = m_listItems;
@@ skipping 153 matching lines @@
 
     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();
     notifyFormStateChanged();
 }
 
 int HTMLSelectElement::optionToListIndex(int optionIndex) const
 {
     const Vector<HTMLElement*>& items = listItems();
@@ skipping 403 matching lines @@
     // 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 (m_activeSelectionAnchorIndex < 0 || !shiftSelect)
         setActiveSelectionAnchorIndex(listIndex);
 
     setActiveSelectionEndIndex(listIndex);
     updateListBoxSelection(!multiSelect);
 }
 
+int HTMLSelectElement::listIndexForEvent(Event* event)
+{
+    const Vector<HTMLElement*>& items = this->listItems();
+    for (Node* node = event->target()->toNode(); node; node = node->parentOrShadowHostNode()) {
+        if (node->isElementNode() && (toElement(node)->hasTagName(optionTag) || toElement(node)->hasTagName(optgroupTag))) {
+            size_t length = items.size();
+            for (size_t i = 0; i < length; ++i) {
+                if (items[i] == node) {
+                    return i;
+                }
+            }
+        }
+    }
+    return -1;
+}
+
 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();
         // Calling focus() may cause us to lose our renderer, in which case do not want to handle the event.
         if (!renderer())
             return;
 
-        // Convert to coords relative to the list box if needed.
         MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
-        IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent->absoluteLocation(), UseTransforms));
-        int listIndex = toRenderListBox(renderer())->listIndexAtOffset(toIntSize(localOffset));
+        int listIndex = listIndexForEvent(event);
         if (listIndex >= 0) {
             if (!isDisabledFormControl()) {
 #if 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()) {
+    } else if (event->type() == eventNames().mousemoveEvent && event->isMouseEvent()) {
         MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
         if (mouseEvent->button() != LeftButton || !mouseEvent->buttonDown())
             return;
 
-        IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent->absoluteLocation(), UseTransforms));
-        int listIndex = toRenderListBox(renderer())->listIndexAtOffset(toIntSize(localOffset));
+        int listIndex = listIndexForEvent(event);
         if (listIndex >= 0) {
             if (!isDisabledFormControl()) {
                 if (m_multiple) {
                     // Only extend selection if there is something selected.
                     if (m_activeSelectionAnchorIndex < 0)
                         return;
 
                     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()) {
-        // This makes sure we fire dispatchFormControlChangeEvent for a single
-        // click. For drag selection, onChange will fire when the autoscroll
-        // timer stops.
+    } else if (event->type() == eventNames().mouseupEvent && event->isMouseEvent() && static_cast<MouseEvent*>(event)->button() == LeftButton)
         listBoxOnChange();
-    } else if (event->type() == eventNames().keydownEvent) {
+    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) {
             // Initialize the end index
             if (keyIdentifier == "Down" || keyIdentifier == "PageDown") {
                 int startIndex = lastSelectedListIndex();
@@ skipping 53 matching lines @@
                 m_activeSelectionState = 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 = !m_multiple || (!static_cast<KeyboardEvent*>(event)->shiftKey() && selectNewItem);
             if (m_activeSelectionAnchorIndex < 0 || deselectOthers) {
                 if (deselectOthers)
                     deselectItemsWithoutValidation();
                 setActiveSelectionAnchorIndex(m_activeSelectionEndIndex);
             }
 
-            toRenderListBox(renderer())->scrollToRevealElementAtListIndex(endIndex);
+            listItems[endIndex]->scrollIntoViewIfNeeded(false);
             if (selectNewItem) {
                 updateListBoxSelection(deselectOthers);
                 listBoxOnChange();
             } else
                 scrollToSelection();
 
             event->setDefaultHandled();
         }
     } else if (event->type() == eventNames().keypressEvent) {
         if (!event->isKeyboardEvent())
@@ skipping 126 matching lines @@
 
     const Vector<HTMLElement*>& items = listItems();
     for (unsigned i = 0; i < items.size(); ++i) {
         if (items[i]->hasTagName(optionTag))
             ++options;
     }
 
     return options;
 }
 
+void HTMLSelectElement::dispatchFormControlChangeEvent()
+{
+    if (renderer() && renderer()->isListBox()) {
+        AXObjectCache* cache = document()->existingAXObjectCache();
+        if (cache)
+            cache->selectedChildrenChanged(renderer());
+    }
+    HTMLFormControlElement::dispatchChangeEvent();
+}
+
 } // namespace