5182cfec5feb6cca4b8f39f28173962d8ce852f3
[WebKit-https.git] / Source / WebCore / dom / DynamicNodeList.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004, 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #include "config.h"
24 #include "DynamicNodeList.h"
25
26 #include "Document.h"
27 #include "Element.h"
28
29 namespace WebCore {
30
31 DynamicSubtreeNodeList::DynamicSubtreeNodeList(PassRefPtr<Node> node, RootType rootType)
32     : DynamicNodeList(node, rootType)
33 {
34 }
35
36 DynamicSubtreeNodeList::~DynamicSubtreeNodeList()
37 {
38 }
39
40 unsigned DynamicSubtreeNodeList::length() const
41 {
42     if (m_caches.isLengthCacheValid)
43         return m_caches.cachedLength;
44
45     unsigned length = 0;
46     Node* rootNode = node();
47
48     for (Node* n = rootNode->firstChild(); n; n = n->traverseNextNode(rootNode))
49         length += n->isElementNode() && nodeMatches(static_cast<Element*>(n));
50
51     m_caches.cachedLength = length;
52     m_caches.isLengthCacheValid = true;
53
54     return length;
55 }
56
57 Node* DynamicSubtreeNodeList::itemForwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const
58 {
59     ASSERT(remainingOffset >= 0);
60     Node* rootNode = node();
61     for (Node* n = start; n; n = n->traverseNextNode(rootNode)) {
62         if (n->isElementNode() && nodeMatches(static_cast<Element*>(n))) {
63             if (!remainingOffset) {
64                 m_caches.lastItem = n;
65                 m_caches.lastItemOffset = offset;
66                 m_caches.isItemCacheValid = true;
67                 return n;
68             }
69             --remainingOffset;
70         }
71     }
72
73     return 0; // no matching node in this subtree
74 }
75
76 Node* DynamicSubtreeNodeList::itemBackwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const
77 {
78     ASSERT(remainingOffset < 0);
79     Node* rootNode = node();
80     for (Node* n = start; n; n = n->traversePreviousNode(rootNode)) {
81         if (n->isElementNode() && nodeMatches(static_cast<Element*>(n))) {
82             if (!remainingOffset) {
83                 m_caches.lastItem = n;
84                 m_caches.lastItemOffset = offset;
85                 m_caches.isItemCacheValid = true;
86                 return n;
87             }
88             ++remainingOffset;
89         }
90     }
91
92     return 0; // no matching node in this subtree
93 }
94
95 Node* DynamicSubtreeNodeList::item(unsigned offset) const
96 {
97     int remainingOffset = offset;
98     Node* start = node()->firstChild();
99     if (m_caches.isItemCacheValid) {
100         if (offset == m_caches.lastItemOffset)
101             return m_caches.lastItem;
102         if (offset > m_caches.lastItemOffset || m_caches.lastItemOffset - offset < offset) {
103             start = m_caches.lastItem;
104             remainingOffset -= m_caches.lastItemOffset;
105         }
106     }
107
108     if (remainingOffset < 0)
109         return itemBackwardsFromCurrent(start, offset, remainingOffset);
110     return itemForwardsFromCurrent(start, offset, remainingOffset);
111 }
112
113 Node* DynamicNodeList::itemWithName(const AtomicString& elementId) const
114 {
115     Node* rootNode = node();
116
117     if (rootNode->inDocument()) {
118         Element* element = rootNode->treeScope()->getElementById(elementId);
119         if (element && nodeMatches(element) && element->isDescendantOf(rootNode))
120             return element;
121         if (!element)
122             return 0;
123         // In the case of multiple nodes with the same name, just fall through.
124     }
125
126     unsigned length = this->length();
127     for (unsigned i = 0; i < length; i++) {
128         Node* node = item(i);
129         // FIXME: This should probably be using getIdAttribute instead of idForStyleResolution.
130         if (node->hasID() && static_cast<Element*>(node)->idForStyleResolution() == elementId)
131             return node;
132     }
133
134     return 0;
135 }
136
137 } // namespace WebCore