OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org) | 2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org) |
3 * (C) 1999 Antti Koivisto (koivisto@kde.org) | 3 * (C) 1999 Antti Koivisto (koivisto@kde.org) |
4 * (C) 2001 Dirk Mueller (mueller@kde.org) | 4 * (C) 2001 Dirk Mueller (mueller@kde.org) |
5 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
All rights reserved. | 5 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
All rights reserved. |
6 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.t
orchmobile.com/) | 6 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.t
orchmobile.com/) |
7 * Copyright (C) 2014 Samsung Electronics. All rights reserved. | 7 * Copyright (C) 2014 Samsung Electronics. All rights reserved. |
8 * | 8 * |
9 * This library is free software; you can redistribute it and/or | 9 * This library is free software; you can redistribute it and/or |
10 * modify it under the terms of the GNU Library General Public | 10 * modify it under the terms of the GNU Library General Public |
(...skipping 13 matching lines...) Expand all Loading... |
24 */ | 24 */ |
25 | 25 |
26 #ifndef ElementTraversal_h | 26 #ifndef ElementTraversal_h |
27 #define ElementTraversal_h | 27 #define ElementTraversal_h |
28 | 28 |
29 #include "core/dom/Element.h" | 29 #include "core/dom/Element.h" |
30 #include "core/dom/NodeTraversal.h" | 30 #include "core/dom/NodeTraversal.h" |
31 | 31 |
32 namespace WebCore { | 32 namespace WebCore { |
33 | 33 |
34 template <class ElementType> | 34 class ElementTraversal { |
35 class Traversal { | |
36 public: | 35 public: |
37 // First / Last element child of the node. | 36 // First / Last element child of the node. |
38 static ElementType* firstWithin(const ContainerNode& current) { return first
ElementWithinTemplate(current); } | 37 static Element* firstWithin(const ContainerNode& current) { return firstElem
entWithinTemplate(current); } |
39 static ElementType* firstWithin(const Node& current) { return firstElementWi
thinTemplate(current); } | 38 static Element* firstWithin(const Node& current) { return firstElementWithin
Template(current); } |
40 static ElementType* lastWithin(const ContainerNode& current) { return lastWi
thinTemplate(current); } | 39 static Element* lastWithin(const ContainerNode& current) { return lastWithin
Template(current); } |
41 static ElementType* lastWithin(const Node& current) { return lastWithinTempl
ate(current); } | 40 static Element* lastWithin(const Node& current) { return lastWithinTemplate(
current); } |
42 | 41 |
43 // Pre-order traversal skipping non-element nodes. | 42 // Pre-order traversal skipping non-element nodes. |
44 static ElementType* next(const ContainerNode& current) { return traverseNext
ElementTemplate(current); } | 43 static Element* next(const ContainerNode& current) { return traverseNextElem
entTemplate(current); } |
45 static ElementType* next(const Node& current) { return traverseNextElementTe
mplate(current); } | 44 static Element* next(const Node& current) { return traverseNextElementTempla
te(current); } |
46 static ElementType* next(const ContainerNode& current, const Node* stayWithi
n) { return traverseNextElementTemplate(current, stayWithin); } | 45 static Element* next(const ContainerNode& current, const Node* stayWithin) {
return traverseNextElementTemplate(current, stayWithin); } |
47 static ElementType* next(const Node& current, const Node* stayWithin) { retu
rn traverseNextElementTemplate(current, stayWithin); } | 46 static Element* next(const Node& current, const Node* stayWithin) { return t
raverseNextElementTemplate(current, stayWithin); } |
48 | 47 |
49 // Like next, but skips children. | 48 // Like next, but skips children. |
50 static ElementType* nextSkippingChildren(const ContainerNode& current) { ret
urn traverseNextElementSkippingChildrenTemplate(current); } | 49 static Element* nextSkippingChildren(const ContainerNode& current) { return
traverseNextElementSkippingChildrenTemplate(current); } |
51 static ElementType* nextSkippingChildren(const Node& current) { return trave
rseNextElementSkippingChildrenTemplate(current); } | 50 static Element* nextSkippingChildren(const Node& current) { return traverseN
extElementSkippingChildrenTemplate(current); } |
52 static ElementType* nextSkippingChildren(const ContainerNode& current, const
Node* stayWithin) { return traverseNextElementSkippingChildrenTemplate(current,
stayWithin); } | 51 static Element* nextSkippingChildren(const ContainerNode& current, const Nod
e* stayWithin) { return traverseNextElementSkippingChildrenTemplate(current, sta
yWithin); } |
53 static ElementType* nextSkippingChildren(const Node& current, const Node* st
ayWithin) { return traverseNextElementSkippingChildrenTemplate(current, stayWith
in); } | 52 static Element* nextSkippingChildren(const Node& current, const Node* stayWi
thin) { return traverseNextElementSkippingChildrenTemplate(current, stayWithin);
} |
54 | 53 |
55 // Pre-order traversal including the pseudo-elements. | 54 // Pre-order traversal including the pseudo-elements. |
56 static ElementType* previousIncludingPseudo(const Node&, const Node* stayWit
hin = 0); | 55 static Element* previousIncludingPseudo(const Node&, const Node* stayWithin
= 0); |
57 static ElementType* nextIncludingPseudo(const Node&, const Node* stayWithin
= 0); | 56 static Element* nextIncludingPseudo(const Node&, const Node* stayWithin = 0)
; |
58 static ElementType* nextIncludingPseudoSkippingChildren(const Node&, const N
ode* stayWithin = 0); | 57 static Element* nextIncludingPseudoSkippingChildren(const Node&, const Node*
stayWithin = 0); |
59 | 58 |
60 // Utility function to traverse only the element and pseudo-element siblings
of a node. | 59 // Utility function to traverse only the element and pseudo-element siblings
of a node. |
61 static ElementType* pseudoAwarePreviousSibling(const Node&); | 60 static Element* pseudoAwarePreviousSibling(const Node&); |
62 | 61 |
63 // Previous / Next sibling. | 62 // Previous / Next sibling. |
64 static ElementType* previousSibling(const Node&); | 63 static Element* previousSibling(const Node&); |
65 static ElementType* nextSibling(const Node&); | 64 static Element* nextSibling(const Node&); |
66 | 65 |
67 private: | 66 private: |
68 template <class NodeType> | 67 template <class NodeType> |
69 static ElementType* firstElementWithinTemplate(NodeType&); | 68 static Element* firstElementWithinTemplate(NodeType&); |
70 template <class NodeType> | 69 template <class NodeType> |
71 static ElementType* lastWithinTemplate(NodeType&); | 70 static Element* lastWithinTemplate(NodeType&); |
72 template <class NodeType> | 71 template <class NodeType> |
73 static ElementType* traverseNextElementTemplate(NodeType&); | 72 static Element* traverseNextElementTemplate(NodeType&); |
74 template <class NodeType> | 73 template <class NodeType> |
75 static ElementType* traverseNextElementTemplate(NodeType&, const Node* stayW
ithin); | 74 static Element* traverseNextElementTemplate(NodeType&, const Node* stayWithi
n); |
76 template <class NodeType> | 75 template <class NodeType> |
77 static ElementType* traverseNextElementSkippingChildrenTemplate(NodeType&); | 76 static Element* traverseNextElementSkippingChildrenTemplate(NodeType&); |
78 template <class NodeType> | 77 template <class NodeType> |
79 static ElementType* traverseNextElementSkippingChildrenTemplate(NodeType&, c
onst Node* stayWithin); | 78 static Element* traverseNextElementSkippingChildrenTemplate(NodeType&, const
Node* stayWithin); |
80 }; | 79 }; |
81 | 80 |
82 typedef Traversal<Element> ElementTraversal; | |
83 | |
84 template <class ElementType> | |
85 template <class NodeType> | 81 template <class NodeType> |
86 inline ElementType* Traversal<ElementType>::firstElementWithinTemplate(NodeType&
current) | 82 inline Element* ElementTraversal::firstElementWithinTemplate(NodeType& current) |
87 { | 83 { |
88 // Except for the root containers, only elements can have element children. | 84 // Except for the root containers, only elements can have element children. |
89 Node* node = current.firstChild(); | 85 Node* node = current.firstChild(); |
90 while (node && !isElementOfType<ElementType>(*node)) | 86 while (node && !node->isElementNode()) |
91 node = node->nextSibling(); | 87 node = node->nextSibling(); |
92 return toElement<ElementType>(node); | 88 return toElement(node); |
93 } | 89 } |
94 | 90 |
95 template <class ElementType> | |
96 template <class NodeType> | 91 template <class NodeType> |
97 inline ElementType* Traversal<ElementType>::lastWithinTemplate(NodeType& current
) | 92 inline Element* ElementTraversal::lastWithinTemplate(NodeType& current) |
98 { | 93 { |
99 Node* node = current.lastChild(); | 94 Node* node = current.lastChild(); |
100 while (node && !isElementOfType<ElementType>(*node)) | 95 while (node && !node->isElementNode()) |
101 node = node->previousSibling(); | 96 node = node->previousSibling(); |
102 return toElement<ElementType>(node); | 97 return toElement(node); |
103 } | 98 } |
104 | 99 |
105 template <class ElementType> | |
106 template <class NodeType> | 100 template <class NodeType> |
107 inline ElementType* Traversal<ElementType>::traverseNextElementTemplate(NodeType
& current) | 101 inline Element* ElementTraversal::traverseNextElementTemplate(NodeType& current) |
108 { | 102 { |
109 Node* node = NodeTraversal::next(current); | 103 Node* node = NodeTraversal::next(current); |
110 while (node && !isElementOfType<ElementType>(*node)) | 104 while (node && !node->isElementNode()) |
111 node = NodeTraversal::nextSkippingChildren(*node); | 105 node = NodeTraversal::nextSkippingChildren(*node); |
112 return toElement<ElementType>(node); | 106 return toElement(node); |
113 } | 107 } |
114 | 108 |
115 template <class ElementType> | |
116 template <class NodeType> | 109 template <class NodeType> |
117 inline ElementType* Traversal<ElementType>::traverseNextElementTemplate(NodeType
& current, const Node* stayWithin) | 110 inline Element* ElementTraversal::traverseNextElementTemplate(NodeType& current,
const Node* stayWithin) |
118 { | 111 { |
119 Node* node = NodeTraversal::next(current, stayWithin); | 112 Node* node = NodeTraversal::next(current, stayWithin); |
120 while (node && !isElementOfType<ElementType>(*node)) | 113 while (node && !node->isElementNode()) |
121 node = NodeTraversal::nextSkippingChildren(*node, stayWithin); | 114 node = NodeTraversal::nextSkippingChildren(*node, stayWithin); |
122 return toElement<ElementType>(node); | 115 return toElement(node); |
123 } | 116 } |
124 | 117 |
125 template <class ElementType> | |
126 template <class NodeType> | 118 template <class NodeType> |
127 inline ElementType* Traversal<ElementType>::traverseNextElementSkippingChildrenT
emplate(NodeType& current) | 119 inline Element* ElementTraversal::traverseNextElementSkippingChildrenTemplate(No
deType& current) |
128 { | 120 { |
129 Node* node = NodeTraversal::nextSkippingChildren(current); | 121 Node* node = NodeTraversal::nextSkippingChildren(current); |
130 while (node && !isElementOfType<ElementType>(*node)) | 122 while (node && !node->isElementNode()) |
131 node = NodeTraversal::nextSkippingChildren(*node); | 123 node = NodeTraversal::nextSkippingChildren(*node); |
132 return toElement<ElementType>(node); | 124 return toElement(node); |
133 } | 125 } |
134 | 126 |
135 template <class ElementType> | |
136 template <class NodeType> | 127 template <class NodeType> |
137 inline ElementType* Traversal<ElementType>::traverseNextElementSkippingChildrenT
emplate(NodeType& current, const Node* stayWithin) | 128 inline Element* ElementTraversal::traverseNextElementSkippingChildrenTemplate(No
deType& current, const Node* stayWithin) |
138 { | 129 { |
139 Node* node = NodeTraversal::nextSkippingChildren(current, stayWithin); | 130 Node* node = NodeTraversal::nextSkippingChildren(current, stayWithin); |
140 while (node && !isElementOfType<ElementType>(*node)) | 131 while (node && !node->isElementNode()) |
141 node = NodeTraversal::nextSkippingChildren(*node, stayWithin); | 132 node = NodeTraversal::nextSkippingChildren(*node, stayWithin); |
142 return toElement<ElementType>(node); | 133 return toElement(node); |
143 } | 134 } |
144 | 135 |
145 template <class ElementType> | 136 inline Element* ElementTraversal::previousIncludingPseudo(const Node& current, c
onst Node* stayWithin) |
146 inline ElementType* Traversal<ElementType>::previousIncludingPseudo(const Node&
current, const Node* stayWithin) | |
147 { | 137 { |
148 Node* node = NodeTraversal::previousIncludingPseudo(current, stayWithin); | 138 Node* node = NodeTraversal::previousIncludingPseudo(current, stayWithin); |
149 while (node && !isElementOfType<ElementType>(*node)) | 139 while (node && !node->isElementNode()) |
150 node = NodeTraversal::previousIncludingPseudo(*node, stayWithin); | 140 node = NodeTraversal::previousIncludingPseudo(*node, stayWithin); |
151 return toElement<ElementType>(node); | 141 return toElement(node); |
152 } | 142 } |
153 | 143 |
154 template <class ElementType> | 144 inline Element* ElementTraversal::nextIncludingPseudo(const Node& current, const
Node* stayWithin) |
155 inline ElementType* Traversal<ElementType>::nextIncludingPseudo(const Node& curr
ent, const Node* stayWithin) | |
156 { | 145 { |
157 Node* node = NodeTraversal::nextIncludingPseudo(current, stayWithin); | 146 Node* node = NodeTraversal::nextIncludingPseudo(current, stayWithin); |
158 while (node && !isElementOfType<ElementType>(*node)) | 147 while (node && !node->isElementNode()) |
159 node = NodeTraversal::nextIncludingPseudo(*node, stayWithin); | 148 node = NodeTraversal::nextIncludingPseudo(*node, stayWithin); |
160 return toElement<ElementType>(node); | 149 return toElement(node); |
161 } | 150 } |
162 | 151 |
163 template <class ElementType> | 152 inline Element* ElementTraversal::nextIncludingPseudoSkippingChildren(const Node
& current, const Node* stayWithin) |
164 inline ElementType* Traversal<ElementType>::nextIncludingPseudoSkippingChildren(
const Node& current, const Node* stayWithin) | |
165 { | 153 { |
166 Node* node = NodeTraversal::nextIncludingPseudoSkippingChildren(current, sta
yWithin); | 154 Node* node = NodeTraversal::nextIncludingPseudoSkippingChildren(current, sta
yWithin); |
167 while (node && !isElementOfType<ElementType>(*node)) | 155 while (node && !node->isElementNode()) |
168 node = NodeTraversal::nextIncludingPseudoSkippingChildren(*node, stayWit
hin); | 156 node = NodeTraversal::nextIncludingPseudoSkippingChildren(*node, stayWit
hin); |
169 return toElement<ElementType>(node); | 157 return toElement(node); |
170 } | 158 } |
171 | 159 |
172 template <class ElementType> | 160 inline Element* ElementTraversal::pseudoAwarePreviousSibling(const Node& current
) |
173 inline ElementType* Traversal<ElementType>::pseudoAwarePreviousSibling(const Nod
e& current) | |
174 { | 161 { |
175 Node* node = current.pseudoAwarePreviousSibling(); | 162 Node* node = current.pseudoAwarePreviousSibling(); |
176 while (node && !isElementOfType<ElementType>(*node)) | 163 while (node && !node->isElementNode()) |
177 node = node->pseudoAwarePreviousSibling(); | 164 node = node->pseudoAwarePreviousSibling(); |
178 return toElement<ElementType>(node); | 165 return toElement(node); |
179 } | 166 } |
180 | 167 |
181 template <class ElementType> | 168 inline Element* ElementTraversal::previousSibling(const Node& current) |
182 inline ElementType* Traversal<ElementType>::previousSibling(const Node& current) | |
183 { | 169 { |
184 Node* node = current.previousSibling(); | 170 Node* node = current.previousSibling(); |
185 while (node && !isElementOfType<ElementType>(*node)) | 171 while (node && !node->isElementNode()) |
186 node = node->previousSibling(); | 172 node = node->previousSibling(); |
187 return toElement<ElementType>(node); | 173 return toElement(node); |
188 } | 174 } |
189 | 175 |
190 template <class ElementType> | 176 inline Element* ElementTraversal::nextSibling(const Node& current) |
191 inline ElementType* Traversal<ElementType>::nextSibling(const Node& current) | |
192 { | 177 { |
193 Node* node = current.nextSibling(); | 178 Node* node = current.nextSibling(); |
194 while (node && !isElementOfType<ElementType>(*node)) | 179 while (node && !node->isElementNode()) |
195 node = node->nextSibling(); | 180 node = node->nextSibling(); |
196 return toElement<ElementType>(node); | 181 return toElement(node); |
197 } | 182 } |
198 | 183 |
199 } // namespace WebCore | 184 } // namespace WebCore |
200 | 185 |
201 #endif | 186 #endif |
OLD | NEW |