Source/WebCore/html/HTMLFormCollection.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2010, 2011, 2012 Apple Inc. All rights reserved.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #include "config.h"
  24 #include "HTMLFormCollection.h"
  25
  26 #include "HTMLFieldSetElement.h"
  27 #include "HTMLFormControlElement.h"
  28 #include "HTMLFormElement.h"
  29 #include "HTMLImageElement.h"
  30 #include "HTMLNames.h"
  31
  32 namespace WebCore {
  33
  34 using namespace HTMLNames;
  35
  36 // Since the collections are to be "live", we have to do the
  37 // calculation every time if anything has changed.
  38
  39 HTMLFormCollection::HTMLFormCollection(Element* base)
  40     : HTMLCollection(base, FormControls)
  41 {
  42     ASSERT(base->hasTagName(formTag) || base->hasTagName(fieldsetTag));
  43 }
  44
  45 PassOwnPtr<HTMLFormCollection> HTMLFormCollection::create(Element* base)
  46 {
  47     return adoptPtr(new HTMLFormCollection(base));
  48 }
  49
  50 HTMLFormCollection::~HTMLFormCollection()
  51 {
  52 }
  53
  54 const Vector<FormAssociatedElement*>& HTMLFormCollection::formControlElements() const
  55 {
  56     ASSERT(base());
  57     ASSERT(base()->hasTagName(formTag) || base()->hasTagName(fieldsetTag));
  58     if (base()->hasTagName(formTag))
  59         return static_cast<HTMLFormElement*>(base())->associatedElements();
  60     return static_cast<HTMLFieldSetElement*>(base())->associatedElements();
  61 }
  62
  63 const Vector<HTMLImageElement*>& HTMLFormCollection::formImageElements() const
  64 {
  65     ASSERT(base());
  66     ASSERT(base()->hasTagName(formTag));
  67     return static_cast<HTMLFormElement*>(base())->imageElements();
  68 }
  69
  70 unsigned HTMLFormCollection::numberOfFormControlElements() const
  71 {
  72     ASSERT(base());
  73     ASSERT(base()->hasTagName(formTag) || base()->hasTagName(fieldsetTag));
  74     if (base()->hasTagName(formTag))
  75         return static_cast<HTMLFormElement*>(base())->length();
  76     return static_cast<HTMLFieldSetElement*>(base())->length();
  77 }
  78
  79 unsigned HTMLFormCollection::calcLength() const
  80 {
  81     return numberOfFormControlElements();
  82 }
  83
  84 Node* HTMLFormCollection::item(unsigned index) const
  85 {
  86     invalidateCacheIfNeeded();
  87
  88     if (isItemCacheValid() && cachedItemOffset() == index)
  89         return cachedItem();
  90
  91     if (isLengthCacheValid() && cachedLength() <= index)
  92         return 0;
  93
  94     if (!isItemCacheValid() || cachedItemOffset() > index)
  95         setItemCache(0, 0, 0);
  96
  97     const Vector<FormAssociatedElement*>& elementsArray = formControlElements();
  98     unsigned currentIndex = cachedItemOffset();
  99
 100     for (unsigned i = cachedElementsArrayOffset(); i < elementsArray.size(); i++) {
 101         if (elementsArray[i]->isEnumeratable()) {
 102             HTMLElement* element = toHTMLElement(elementsArray[i]);
 103             if (index == currentIndex) {
 104                 setItemCache(element, index, i);
 105                 return element;
 106             }
 107
 108             currentIndex++;
 109         }
 110     }
 111
 112     return 0;
 113 }
 114
 115 static HTMLElement* firstNamedItem(const Vector<FormAssociatedElement*>& elementsArray,
 116     const Vector<HTMLImageElement*>* imageElementsArray, const QualifiedName& attrName, const String& name)
 117 {
 118     ASSERT(attrName == idAttr || attrName == nameAttr);
 119
 120     for (unsigned i = 0; i < elementsArray.size(); ++i) {
 121         HTMLElement* element = toHTMLElement(elementsArray[i]);
 122         if (elementsArray[i]->isEnumeratable() && element->fastGetAttribute(attrName) == name)
 123             return element;
 124     }
 125
 126     if (!imageElementsArray)
 127         return 0;
 128
 129     for (unsigned i = 0; i < imageElementsArray->size(); ++i) {
 130         HTMLImageElement* element = (*imageElementsArray)[i];
 131         if (element->fastGetAttribute(attrName) == name)
 132             return element;
 133     }
 134
 135     return 0;
 136 }
 137
 138 Node* HTMLFormCollection::namedItem(const AtomicString& name) const
 139 {
 140     // http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/nameditem.asp
 141     // This method first searches for an object with a matching id
 142     // attribute. If a match is not found, the method then searches for an
 143     // object with a matching name attribute, but only on those elements
 144     // that are allowed a name attribute.
 145     invalidateCacheIfNeeded();
 146     const Vector<HTMLImageElement*>* imagesElements = base()->hasTagName(fieldsetTag) ? 0 : &formImageElements();
 147     if (HTMLElement* item = firstNamedItem(formControlElements(), imagesElements, idAttr, name))
 148         return item;
 149
 150     return firstNamedItem(formControlElements(), imagesElements, nameAttr, name);
 151 }
 152
 153 void HTMLFormCollection::updateNameCache() const
 154 {
 155     if (hasNameCache())
 156         return;
 157
 158     HashSet<AtomicStringImpl*> foundInputElements;
 159
 160     const Vector<FormAssociatedElement*>& elementsArray = formControlElements();
 161
 162     for (unsigned i = 0; i < elementsArray.size(); ++i) {
 163         FormAssociatedElement* associatedElement = elementsArray[i];
 164         if (associatedElement->isEnumeratable()) {
 165             HTMLElement* element = toHTMLElement(associatedElement);
 166             const AtomicString& idAttrVal = element->getIdAttribute();
 167             const AtomicString& nameAttrVal = element->getNameAttribute();
 168             if (!idAttrVal.isEmpty()) {
 169                 appendIdCache(idAttrVal, element);
 170                 foundInputElements.add(idAttrVal.impl());
 171             }
 172             if (!nameAttrVal.isEmpty() && idAttrVal != nameAttrVal) {
 173                 appendNameCache(nameAttrVal, element);
 174                 foundInputElements.add(nameAttrVal.impl());
 175             }
 176         }
 177     }
 178
 179     if (base()->hasTagName(formTag)) {
 180         const Vector<HTMLImageElement*>& imageElementsArray = formImageElements();
 181         for (unsigned i = 0; i < imageElementsArray.size(); ++i) {
 182             HTMLImageElement* element = imageElementsArray[i];
 183             const AtomicString& idAttrVal = element->getIdAttribute();
 184             const AtomicString& nameAttrVal = element->getNameAttribute();
 185             if (!idAttrVal.isEmpty() && !foundInputElements.contains(idAttrVal.impl()))
 186                 appendIdCache(idAttrVal, element);
 187             if (!nameAttrVal.isEmpty() && idAttrVal != nameAttrVal && !foundInputElements.contains(nameAttrVal.impl()))
 188                 appendNameCache(nameAttrVal, element);
 189         }
 190     }
 191
 192     setHasNameCache();
 193 }
 194
 195 }