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, 2008 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 "HTMLCollection.h"

    25 

    26 #include "HTMLDocument.h"

    27 #include "HTMLElement.h"

    28 #include "HTMLNames.h"

    29 #include "HTMLObjectElement.h"

    30 #include "HTMLOptionElement.h"

    31 #include "NodeList.h"

    32 

    33 #include <utility>

    34 

    35 namespace WebCore {

    36 

    37 using namespace HTMLNames;

    38 

    39 HTMLCollection::HTMLCollection(PassRefPtr<Node> base, CollectionType type)

    40     : m_idsDone(false)

    41     , m_base(base)

    42     , m_type(type)

    43     , m_info(m_base->isDocumentNode() ? static_cast<Document*>(m_base.get())->collectionInfo(type) : 0)

    44     , m_ownsInfo(false)

    45 {

    46 }

    47 

    48 HTMLCollection::HTMLCollection(PassRefPtr<Node> base, CollectionType type, CollectionCache* info)

    49     : m_idsDone(false)

    50     , m_base(base)

    51     , m_type(type)

    52     , m_info(info)

    53     , m_ownsInfo(false)

    54 {

    55 }

    56 

    57 PassRefPtr<HTMLCollection> HTMLCollection::create(PassRefPtr<Node> base, CollectionType type)

    58 {

    59     return adoptRef(new HTMLCollection(base, type));

    60 }

    61 

    62 HTMLCollection::~HTMLCollection()

    63 {

    64     if (m_ownsInfo)

    65         delete m_info;

    66 }

    67 

    68 void HTMLCollection::resetCollectionInfo() const

    69 {

    70     unsigned docversion = static_cast<HTMLDocument*>(m_base->document())->domTreeVersion();

    71 

    72     if (!m_info) {

    73         m_info = new CollectionCache;

    74         m_ownsInfo = true;

    75         m_info->version = docversion;

    76         return;

    77     }

    78 

    79     if (m_info->version != docversion) {

    80         m_info->reset();

    81         m_info->version = docversion;

    82     }

    83 }

    84 

    85 static Node* nextNodeOrSibling(Node* base, Node* node, bool includeChildren)

    86 {

    87     return includeChildren ? node->traverseNextNode(base) : node->traverseNextSibling(base);

    88 }

    89 

    90 Element* HTMLCollection::itemAfter(Element* previous) const

    91 {

    92     bool deep = true;

    93 

    94     switch (m_type) {

    95         case DocAll:

    96         case DocAnchors:

    97         case DocApplets:

    98         case DocEmbeds:

    99         case DocForms:

   100         case DocImages:

   101         case DocLinks:

   102         case DocObjects:

   103         case DocScripts:

   104         case DocumentNamedItems:

   105         case MapAreas:

   106         case OtherCollection:

   107         case SelectOptions:

   108         case DataListOptions:

   109         case WindowNamedItems:

   110             break;

   111         case NodeChildren:

   112         case TRCells:

   113         case TSectionRows:

   114         case TableTBodies:

   115             deep = false;

   116             break;

   117     }

   118 

   119     Node* current;

   120     if (!previous)

   121         current = m_base->firstChild();

   122     else

   123         current = nextNodeOrSibling(m_base.get(), previous, deep);

   124 

   125     for (; current; current = nextNodeOrSibling(m_base.get(), current, deep)) {

   126         if (!current->isElementNode())

   127             continue;

   128         Element* e = static_cast<Element*>(current);

   129         switch (m_type) {

   130             case DocImages:

   131                 if (e->hasLocalName(imgTag))

   132                     return e;

   133                 break;

   134             case DocScripts:

   135                 if (e->hasLocalName(scriptTag))

   136                     return e;

   137                 break;

   138             case DocForms:

   139                 if (e->hasLocalName(formTag))

   140                     return e;

   141                 break;

   142             case TableTBodies:

   143                 if (e->hasLocalName(tbodyTag))

   144                     return e;

   145                 break;

   146             case TRCells:

   147                 if (e->hasLocalName(tdTag) || e->hasLocalName(thTag))

   148                     return e;

   149                 break;

   150             case TSectionRows:

   151                 if (e->hasLocalName(trTag))

   152                     return e;

   153                 break;

   154             case SelectOptions:

   155                 if (e->hasLocalName(optionTag))

   156                     return e;

   157                 break;

   158             case DataListOptions:

   159                 if (e->hasLocalName(optionTag)) {

   160                     HTMLOptionElement* option = static_cast<HTMLOptionElement*>(e);

   161                     if (!option->disabled() && !option->value().isEmpty())

   162                         return e;

   163                 }

   164                 break;

   165             case MapAreas:

   166                 if (e->hasLocalName(areaTag))

   167                     return e;

   168                 break;

   169             case DocApplets: // all <applet> elements and <object> elements that contain Java Applets

   170                 if (e->hasLocalName(appletTag))

   171                     return e;

   172                 if (e->hasLocalName(objectTag) && static_cast<HTMLObjectElement*>(e)->containsJavaApplet())

   173                     return e;

   174                 break;

   175             case DocEmbeds:

   176                 if (e->hasLocalName(embedTag))

   177                     return e;

   178                 break;

   179             case DocObjects:

   180                 if (e->hasLocalName(objectTag))

   181                     return e;

   182                 break;

   183             case DocLinks: // all <a> and <area> elements with a value for href

   184                 if ((e->hasLocalName(aTag) || e->hasLocalName(areaTag)) && (!e->getAttribute(hrefAttr).isNull()))

   185                     return e;

   186                 break;

   187             case DocAnchors: // all <a> elements with a value for name

   188                 if (e->hasLocalName(aTag) && !e->getAttribute(nameAttr).isNull())

   189                     return e;

   190                 break;

   191             case DocAll:

   192             case NodeChildren:

   193                 return e;

   194             case DocumentNamedItems:

   195             case OtherCollection:

   196             case WindowNamedItems:

   197                 ASSERT_NOT_REACHED();

   198                 break;

   199         }

   200     }

   201 

   202     return 0;

   203 }

   204 

   205 unsigned HTMLCollection::calcLength() const

   206 {

   207     unsigned len = 0;

   208     for (Element* current = itemAfter(0); current; current = itemAfter(current))

   209         ++len;

   210     return len;

   211 }

   212 

   213 // since the collections are to be "live", we have to do the

   214 // calculation every time if anything has changed

   215 unsigned HTMLCollection::length() const

   216 {

   217     resetCollectionInfo();

   218     if (!m_info->hasLength) {

   219         m_info->length = calcLength();

   220         m_info->hasLength = true;

   221     }

   222     return m_info->length;

   223 }

   224 

   225 Node* HTMLCollection::item(unsigned index) const

   226 {

   227      resetCollectionInfo();

   228      if (m_info->current && m_info->position == index)

   229          return m_info->current;

   230      if (m_info->hasLength && m_info->length <= index)

   231          return 0;

   232      if (!m_info->current || m_info->position > index) {

   233          m_info->current = itemAfter(0);

   234          m_info->position = 0;

   235          if (!m_info->current)

   236              return 0;

   237      }

   238      Element* e = m_info->current;

   239      for (unsigned pos = m_info->position; e && pos < index; pos++)

   240          e = itemAfter(e);

   241      m_info->current = e;

   242      m_info->position = index;

   243      return m_info->current;

   244 }

   245 

   246 Node* HTMLCollection::firstItem() const

   247 {

   248      return item(0);

   249 }

   250 

   251 Node* HTMLCollection::nextItem() const

   252 {

   253      resetCollectionInfo();

   254  

   255      // Look for the 'second' item. The first one is currentItem, already given back.

   256      Element* retval = itemAfter(m_info->current);

   257      m_info->current = retval;

   258      m_info->position++;

   259      return retval;

   260 }

   261 

   262 bool HTMLCollection::checkForNameMatch(Element* element, bool checkName, const AtomicString& name) const

   263 {

   264     if (!element->isHTMLElement())

   265         return false;

   266     

   267     HTMLElement* e = static_cast<HTMLElement*>(element);

   268     if (!checkName)

   269         return e->getIdAttribute() == name;

   270 

   271     // document.all returns only images, forms, applets, objects and embeds

   272     // by name (though everything by id)

   273     if (m_type == DocAll && 

   274         !(e->hasLocalName(imgTag) || e->hasLocalName(formTag) ||

   275           e->hasLocalName(appletTag) || e->hasLocalName(objectTag) ||

   276           e->hasLocalName(embedTag) || e->hasLocalName(inputTag) ||

   277           e->hasLocalName(selectTag)))

   278         return false;

   279 

   280     return e->getAttribute(nameAttr) == name && e->getIdAttribute() != name;

   281 }

   282 

   283 Node* HTMLCollection::namedItem(const AtomicString& name) const

   284 {

   285     // http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/nameditem.asp

   286     // This method first searches for an object with a matching id

   287     // attribute. If a match is not found, the method then searches for an

   288     // object with a matching name attribute, but only on those elements

   289     // that are allowed a name attribute.

   290     resetCollectionInfo();

   291     m_idsDone = false;

   292 

   293     for (Element* e = itemAfter(0); e; e = itemAfter(e)) {

   294         if (checkForNameMatch(e, m_idsDone, name)) {

   295             m_info->current = e;

   296             return e;

   297         }

   298     }

   299         

   300     m_idsDone = true;

   301 

   302     for (Element* e = itemAfter(0); e; e = itemAfter(e)) {

   303         if (checkForNameMatch(e, m_idsDone, name)) {

   304             m_info->current = e;

   305             return e;

   306         }

   307     }

   308 

   309     m_info->current = 0;

   310     return 0;

   311 }

   312 

   313 void HTMLCollection::updateNameCache() const

   314 {

   315     if (m_info->hasNameCache)

   316         return;

   317     

   318     for (Element* element = itemAfter(0); element; element = itemAfter(element)) {

   319         if (!element->isHTMLElement())

   320             continue;

   321         HTMLElement* e = static_cast<HTMLElement*>(element);

   322         const AtomicString& idAttrVal = e->getIdAttribute();

   323         const AtomicString& nameAttrVal = e->getAttribute(nameAttr);

   324         if (!idAttrVal.isEmpty()) {

   325             // add to id cache

   326             Vector<Element*>* idVector = m_info->idCache.get(idAttrVal.impl());

   327             if (!idVector) {

   328                 idVector = new Vector<Element*>;

   329                 m_info->idCache.add(idAttrVal.impl(), idVector);

   330             }

   331             idVector->append(e);

   332         }

   333         if (!nameAttrVal.isEmpty() && idAttrVal != nameAttrVal

   334             && (m_type != DocAll || 

   335                 (e->hasLocalName(imgTag) || e->hasLocalName(formTag) ||

   336                  e->hasLocalName(appletTag) || e->hasLocalName(objectTag) ||

   337                  e->hasLocalName(embedTag) || e->hasLocalName(inputTag) ||

   338                  e->hasLocalName(selectTag)))) {

   339             // add to name cache

   340             Vector<Element*>* nameVector = m_info->nameCache.get(nameAttrVal.impl());

   341             if (!nameVector) {

   342                 nameVector = new Vector<Element*>;

   343                 m_info->nameCache.add(nameAttrVal.impl(), nameVector);

   344             }

   345             nameVector->append(e);

   346         }

   347     }

   348 

   349     m_info->hasNameCache = true;

   350 }

   351 

   352 void HTMLCollection::namedItems(const AtomicString& name, Vector<RefPtr<Node> >& result) const

   353 {

   354     ASSERT(result.isEmpty());

   355     

   356     if (name.isEmpty())

   357         return;

   358 

   359     resetCollectionInfo();

   360     updateNameCache();

   361     m_info->checkConsistency();

   362 

   363     Vector<Element*>* idResults = m_info->idCache.get(name.impl());

   364     Vector<Element*>* nameResults = m_info->nameCache.get(name.impl());

   365     

   366     for (unsigned i = 0; idResults && i < idResults->size(); ++i)

   367         result.append(idResults->at(i));

   368 

   369     for (unsigned i = 0; nameResults && i < nameResults->size(); ++i)

   370         result.append(nameResults->at(i));

   371 }

   372 

   373 

   374 Node* HTMLCollection::nextNamedItem(const AtomicString& name) const

   375 {

   376     resetCollectionInfo();

   377     m_info->checkConsistency();

   378 

   379     for (Element* e = itemAfter(m_info->current); e; e = itemAfter(e)) {

   380         if (checkForNameMatch(e, m_idsDone, name)) {

   381             m_info->current = e;

   382             return e;

   383         }

   384     }

   385     

   386     if (m_idsDone) {

   387         m_info->current = 0; 

   388         return 0;

   389     }

   390     m_idsDone = true;

   391 

   392     for (Element* e = itemAfter(m_info->current); e; e = itemAfter(e)) {

   393         if (checkForNameMatch(e, m_idsDone, name)) {

   394             m_info->current = e;

   395             return e;

   396         }

   397     }

   398 

   399     return 0;

   400 }

   401 

   402 PassRefPtr<NodeList> HTMLCollection::tags(const String& name)

   403 {

   404     return m_base->getElementsByTagName(name);

   405 }

   406 

   407 } // namespace WebCore