12005
|
1 |
/*
|
33349
|
2 |
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
|
12005
|
3 |
*/
|
|
4 |
/*
|
33349
|
5 |
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
6 |
* contributor license agreements. See the NOTICE file distributed with
|
|
7 |
* this work for additional information regarding copyright ownership.
|
|
8 |
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
9 |
* (the "License"); you may not use this file except in compliance with
|
|
10 |
* the License. You may obtain a copy of the License at
|
12005
|
11 |
*
|
|
12 |
* http://www.apache.org/licenses/LICENSE-2.0
|
|
13 |
*
|
|
14 |
* Unless required by applicable law or agreed to in writing, software
|
|
15 |
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
16 |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
17 |
* See the License for the specific language governing permissions and
|
|
18 |
* limitations under the License.
|
|
19 |
*/
|
|
20 |
|
|
21 |
package com.sun.org.apache.xerces.internal.dom;
|
|
22 |
|
|
23 |
import com.sun.org.apache.xerces.internal.dom.events.EventImpl;
|
|
24 |
import com.sun.org.apache.xerces.internal.dom.events.MutationEventImpl;
|
33349
|
25 |
import java.io.IOException;
|
|
26 |
import java.io.ObjectInputStream;
|
|
27 |
import java.io.ObjectOutputStream;
|
|
28 |
import java.io.ObjectStreamField;
|
|
29 |
import java.io.Serializable;
|
|
30 |
import java.util.ArrayList;
|
|
31 |
import java.util.HashMap;
|
|
32 |
import java.util.Hashtable;
|
|
33 |
import java.util.List;
|
|
34 |
import java.util.Map;
|
|
35 |
import java.util.Vector;
|
12005
|
36 |
import org.w3c.dom.Attr;
|
|
37 |
import org.w3c.dom.DOMException;
|
|
38 |
import org.w3c.dom.DOMImplementation;
|
|
39 |
import org.w3c.dom.DocumentType;
|
|
40 |
import org.w3c.dom.Element;
|
|
41 |
import org.w3c.dom.NamedNodeMap;
|
|
42 |
import org.w3c.dom.Node;
|
33349
|
43 |
import org.w3c.dom.UserDataHandler;
|
12005
|
44 |
import org.w3c.dom.events.DocumentEvent;
|
|
45 |
import org.w3c.dom.events.Event;
|
|
46 |
import org.w3c.dom.events.EventException;
|
|
47 |
import org.w3c.dom.events.EventListener;
|
|
48 |
import org.w3c.dom.events.MutationEvent;
|
|
49 |
import org.w3c.dom.ranges.DocumentRange;
|
|
50 |
import org.w3c.dom.ranges.Range;
|
|
51 |
import org.w3c.dom.traversal.DocumentTraversal;
|
|
52 |
import org.w3c.dom.traversal.NodeFilter;
|
|
53 |
import org.w3c.dom.traversal.NodeIterator;
|
|
54 |
import org.w3c.dom.traversal.TreeWalker;
|
|
55 |
|
|
56 |
|
|
57 |
/**
|
|
58 |
* The Document interface represents the entire HTML or XML document.
|
|
59 |
* Conceptually, it is the root of the document tree, and provides the
|
|
60 |
* primary access to the document's data.
|
|
61 |
* <P>
|
|
62 |
* Since elements, text nodes, comments, processing instructions,
|
|
63 |
* etc. cannot exist outside the context of a Document, the Document
|
|
64 |
* interface also contains the factory methods needed to create these
|
|
65 |
* objects. The Node objects created have a ownerDocument attribute
|
|
66 |
* which associates them with the Document within whose context they
|
|
67 |
* were created.
|
|
68 |
* <p>
|
|
69 |
* The DocumentImpl class also implements the DOM Level 2 DocumentTraversal
|
|
70 |
* interface. This interface is comprised of factory methods needed to
|
|
71 |
* create NodeIterators and TreeWalkers. The process of creating NodeIterator
|
|
72 |
* objects also adds these references to this document.
|
|
73 |
* After finishing with an iterator it is important to remove the object
|
|
74 |
* using the remove methods in this implementation. This allows the release of
|
|
75 |
* the references from the iterator objects to the DOM Nodes.
|
|
76 |
* <p>
|
|
77 |
* <b>Note:</b> When any node in the document is serialized, the
|
|
78 |
* entire document is serialized along with it.
|
|
79 |
*
|
|
80 |
* @xerces.internal
|
|
81 |
*
|
|
82 |
* @author Arnaud Le Hors, IBM
|
|
83 |
* @author Joe Kesselman, IBM
|
|
84 |
* @author Andy Clark, IBM
|
|
85 |
* @author Ralf Pfeiffer, IBM
|
|
86 |
* @since PR-DOM-Level-1-19980818.
|
|
87 |
*/
|
|
88 |
public class DocumentImpl
|
|
89 |
extends CoreDocumentImpl
|
|
90 |
implements DocumentTraversal, DocumentEvent, DocumentRange {
|
|
91 |
|
|
92 |
//
|
|
93 |
// Constants
|
|
94 |
//
|
|
95 |
|
|
96 |
/** Serialization version. */
|
|
97 |
static final long serialVersionUID = 515687835542616694L;
|
|
98 |
|
|
99 |
//
|
|
100 |
// Data
|
|
101 |
//
|
|
102 |
|
|
103 |
/** Iterators */
|
|
104 |
// REVISIT: Should this be transient? -Ac
|
33349
|
105 |
protected List<NodeIterator> iterators;
|
12005
|
106 |
|
|
107 |
/** Ranges */
|
|
108 |
// REVISIT: Should this be transient? -Ac
|
33349
|
109 |
protected List<Range> ranges;
|
12005
|
110 |
|
|
111 |
/** Table for event listeners registered to this document nodes. */
|
33349
|
112 |
protected Map<NodeImpl, List<LEntry>> eventListeners;
|
12005
|
113 |
|
|
114 |
/** Bypass mutation events firing. */
|
|
115 |
protected boolean mutationEvents = false;
|
|
116 |
|
33349
|
117 |
|
|
118 |
/**
|
|
119 |
* @serialField iterators Vector Node iterators
|
|
120 |
* @serialField ranges Vector ranges
|
|
121 |
* @serialField eventListeners Hashtable Event listeners
|
|
122 |
* @serialField mutationEvents boolean Bypass mutation events firing
|
|
123 |
*/
|
|
124 |
private static final ObjectStreamField[] serialPersistentFields =
|
|
125 |
new ObjectStreamField[] {
|
|
126 |
new ObjectStreamField("iterators", Vector.class),
|
|
127 |
new ObjectStreamField("ranges", Vector.class),
|
|
128 |
new ObjectStreamField("eventListeners", Hashtable.class),
|
|
129 |
new ObjectStreamField("mutationEvents", boolean.class),
|
|
130 |
};
|
|
131 |
|
12005
|
132 |
//
|
|
133 |
// Constructors
|
|
134 |
//
|
|
135 |
|
|
136 |
/**
|
|
137 |
* NON-DOM: Actually creating a Document is outside the DOM's spec,
|
|
138 |
* since it has to operate in terms of a particular implementation.
|
|
139 |
*/
|
|
140 |
public DocumentImpl() {
|
|
141 |
super();
|
|
142 |
}
|
|
143 |
|
|
144 |
/** Constructor. */
|
|
145 |
public DocumentImpl(boolean grammarAccess) {
|
|
146 |
super(grammarAccess);
|
|
147 |
}
|
|
148 |
|
|
149 |
/**
|
|
150 |
* For DOM2 support.
|
|
151 |
* The createDocument factory method is in DOMImplementation.
|
|
152 |
*/
|
|
153 |
public DocumentImpl(DocumentType doctype)
|
|
154 |
{
|
|
155 |
super(doctype);
|
|
156 |
}
|
|
157 |
|
|
158 |
/** For DOM2 support. */
|
|
159 |
public DocumentImpl(DocumentType doctype, boolean grammarAccess) {
|
|
160 |
super(doctype, grammarAccess);
|
|
161 |
}
|
|
162 |
|
|
163 |
//
|
|
164 |
// Node methods
|
|
165 |
//
|
|
166 |
|
|
167 |
/**
|
|
168 |
* Deep-clone a document, including fixing ownerDoc for the cloned
|
|
169 |
* children. Note that this requires bypassing the WRONG_DOCUMENT_ERR
|
|
170 |
* protection. I've chosen to implement it by calling importNode
|
|
171 |
* which is DOM Level 2.
|
|
172 |
*
|
|
173 |
* @return org.w3c.dom.Node
|
|
174 |
* @param deep boolean, iff true replicate children
|
|
175 |
*/
|
|
176 |
public Node cloneNode(boolean deep) {
|
|
177 |
|
|
178 |
DocumentImpl newdoc = new DocumentImpl();
|
|
179 |
callUserDataHandlers(this, newdoc, UserDataHandler.NODE_CLONED);
|
|
180 |
cloneNode(newdoc, deep);
|
|
181 |
|
|
182 |
// experimental
|
|
183 |
newdoc.mutationEvents = mutationEvents;
|
|
184 |
|
|
185 |
return newdoc;
|
|
186 |
|
|
187 |
} // cloneNode(boolean):Node
|
|
188 |
|
|
189 |
/**
|
|
190 |
* Retrieve information describing the abilities of this particular
|
|
191 |
* DOM implementation. Intended to support applications that may be
|
|
192 |
* using DOMs retrieved from several different sources, potentially
|
|
193 |
* with different underlying representations.
|
|
194 |
*/
|
|
195 |
public DOMImplementation getImplementation() {
|
|
196 |
// Currently implemented as a singleton, since it's hardcoded
|
|
197 |
// information anyway.
|
|
198 |
return DOMImplementationImpl.getDOMImplementation();
|
|
199 |
}
|
|
200 |
|
|
201 |
//
|
|
202 |
// DocumentTraversal methods
|
|
203 |
//
|
|
204 |
|
|
205 |
/**
|
|
206 |
* NON-DOM extension:
|
|
207 |
* Create and return a NodeIterator. The NodeIterator is
|
|
208 |
* added to a list of NodeIterators so that it can be
|
|
209 |
* removed to free up the DOM Nodes it references.
|
|
210 |
*
|
|
211 |
* @param root The root of the iterator.
|
|
212 |
* @param whatToShow The whatToShow mask.
|
|
213 |
* @param filter The NodeFilter installed. Null means no filter.
|
|
214 |
*/
|
|
215 |
public NodeIterator createNodeIterator(Node root,
|
|
216 |
short whatToShow,
|
|
217 |
NodeFilter filter)
|
|
218 |
{
|
|
219 |
return createNodeIterator(root, whatToShow, filter, true);
|
|
220 |
}
|
|
221 |
|
|
222 |
/**
|
|
223 |
* Create and return a NodeIterator. The NodeIterator is
|
|
224 |
* added to a list of NodeIterators so that it can be
|
|
225 |
* removed to free up the DOM Nodes it references.
|
|
226 |
*
|
|
227 |
* @param root The root of the iterator.
|
|
228 |
* @param whatToShow The whatToShow mask.
|
|
229 |
* @param filter The NodeFilter installed. Null means no filter.
|
|
230 |
* @param entityReferenceExpansion true to expand the contents of
|
|
231 |
* EntityReference nodes
|
|
232 |
* @since WD-DOM-Level-2-19990923
|
|
233 |
*/
|
|
234 |
public NodeIterator createNodeIterator(Node root,
|
|
235 |
int whatToShow,
|
|
236 |
NodeFilter filter,
|
|
237 |
boolean entityReferenceExpansion)
|
|
238 |
{
|
|
239 |
|
|
240 |
if (root == null) {
|
|
241 |
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NOT_SUPPORTED_ERR", null);
|
|
242 |
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
|
|
243 |
}
|
|
244 |
|
|
245 |
NodeIterator iterator = new NodeIteratorImpl(this,
|
|
246 |
root,
|
|
247 |
whatToShow,
|
|
248 |
filter,
|
|
249 |
entityReferenceExpansion);
|
|
250 |
if (iterators == null) {
|
33349
|
251 |
iterators = new ArrayList<>();
|
12005
|
252 |
}
|
|
253 |
|
33349
|
254 |
iterators.add(iterator);
|
12005
|
255 |
|
|
256 |
return iterator;
|
|
257 |
}
|
|
258 |
|
|
259 |
/**
|
|
260 |
* NON-DOM extension:
|
|
261 |
* Create and return a TreeWalker.
|
|
262 |
*
|
|
263 |
* @param root The root of the iterator.
|
|
264 |
* @param whatToShow The whatToShow mask.
|
|
265 |
* @param filter The NodeFilter installed. Null means no filter.
|
|
266 |
*/
|
|
267 |
public TreeWalker createTreeWalker(Node root,
|
|
268 |
short whatToShow,
|
|
269 |
NodeFilter filter)
|
|
270 |
{
|
|
271 |
return createTreeWalker(root, whatToShow, filter, true);
|
|
272 |
}
|
|
273 |
/**
|
|
274 |
* Create and return a TreeWalker.
|
|
275 |
*
|
|
276 |
* @param root The root of the iterator.
|
|
277 |
* @param whatToShow The whatToShow mask.
|
|
278 |
* @param filter The NodeFilter installed. Null means no filter.
|
|
279 |
* @param entityReferenceExpansion true to expand the contents of
|
|
280 |
* EntityReference nodes
|
|
281 |
* @since WD-DOM-Level-2-19990923
|
|
282 |
*/
|
|
283 |
public TreeWalker createTreeWalker(Node root,
|
|
284 |
int whatToShow,
|
|
285 |
NodeFilter filter,
|
|
286 |
boolean entityReferenceExpansion)
|
|
287 |
{
|
|
288 |
if (root == null) {
|
|
289 |
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NOT_SUPPORTED_ERR", null);
|
|
290 |
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
|
|
291 |
}
|
|
292 |
return new TreeWalkerImpl(root, whatToShow, filter,
|
|
293 |
entityReferenceExpansion);
|
|
294 |
}
|
|
295 |
|
|
296 |
//
|
|
297 |
// Not DOM Level 2. Support DocumentTraversal methods.
|
|
298 |
//
|
|
299 |
|
|
300 |
/** This is not called by the developer client. The
|
|
301 |
* developer client uses the detach() function on the
|
|
302 |
* NodeIterator itself. <p>
|
|
303 |
*
|
|
304 |
* This function is called from the NodeIterator#detach().
|
|
305 |
*/
|
|
306 |
void removeNodeIterator(NodeIterator nodeIterator) {
|
|
307 |
|
|
308 |
if (nodeIterator == null) return;
|
|
309 |
if (iterators == null) return;
|
|
310 |
|
33349
|
311 |
iterators.remove(nodeIterator);
|
12005
|
312 |
}
|
|
313 |
|
|
314 |
//
|
|
315 |
// DocumentRange methods
|
|
316 |
//
|
|
317 |
/**
|
|
318 |
*/
|
|
319 |
public Range createRange() {
|
|
320 |
|
|
321 |
if (ranges == null) {
|
33349
|
322 |
ranges = new ArrayList<>();
|
12005
|
323 |
}
|
|
324 |
|
|
325 |
Range range = new RangeImpl(this);
|
33349
|
326 |
ranges.add(range);
|
12005
|
327 |
|
|
328 |
return range;
|
|
329 |
|
|
330 |
}
|
|
331 |
|
|
332 |
/** Not a client function. Called by Range.detach(),
|
|
333 |
* so a Range can remove itself from the list of
|
|
334 |
* Ranges.
|
|
335 |
*/
|
|
336 |
void removeRange(Range range) {
|
|
337 |
|
|
338 |
if (range == null) return;
|
|
339 |
if (ranges == null) return;
|
|
340 |
|
33349
|
341 |
ranges.remove(range);
|
12005
|
342 |
}
|
|
343 |
|
|
344 |
/**
|
|
345 |
* A method to be called when some text was changed in a text node,
|
|
346 |
* so that live objects can be notified.
|
|
347 |
*/
|
|
348 |
void replacedText(NodeImpl node) {
|
|
349 |
// notify ranges
|
|
350 |
if (ranges != null) {
|
|
351 |
int size = ranges.size();
|
|
352 |
for (int i = 0; i != size; i++) {
|
33349
|
353 |
((RangeImpl)ranges.get(i)).receiveReplacedText(node);
|
12005
|
354 |
}
|
|
355 |
}
|
|
356 |
}
|
|
357 |
|
|
358 |
/**
|
|
359 |
* A method to be called when some text was deleted from a text node,
|
|
360 |
* so that live objects can be notified.
|
|
361 |
*/
|
|
362 |
void deletedText(NodeImpl node, int offset, int count) {
|
|
363 |
// notify ranges
|
|
364 |
if (ranges != null) {
|
|
365 |
int size = ranges.size();
|
|
366 |
for (int i = 0; i != size; i++) {
|
33349
|
367 |
((RangeImpl)ranges.get(i)).receiveDeletedText(node,
|
12005
|
368 |
offset, count);
|
|
369 |
}
|
|
370 |
}
|
|
371 |
}
|
|
372 |
|
|
373 |
/**
|
|
374 |
* A method to be called when some text was inserted into a text node,
|
|
375 |
* so that live objects can be notified.
|
|
376 |
*/
|
|
377 |
void insertedText(NodeImpl node, int offset, int count) {
|
|
378 |
// notify ranges
|
|
379 |
if (ranges != null) {
|
|
380 |
int size = ranges.size();
|
|
381 |
for (int i = 0; i != size; i++) {
|
33349
|
382 |
((RangeImpl)ranges.get(i)).receiveInsertedText(node,
|
12005
|
383 |
offset, count);
|
|
384 |
}
|
|
385 |
}
|
|
386 |
}
|
|
387 |
|
|
388 |
/**
|
|
389 |
* A method to be called when a text node has been split,
|
|
390 |
* so that live objects can be notified.
|
|
391 |
*/
|
|
392 |
void splitData(Node node, Node newNode, int offset) {
|
|
393 |
// notify ranges
|
|
394 |
if (ranges != null) {
|
|
395 |
int size = ranges.size();
|
|
396 |
for (int i = 0; i != size; i++) {
|
33349
|
397 |
((RangeImpl)ranges.get(i)).receiveSplitData(node,
|
12005
|
398 |
newNode, offset);
|
|
399 |
}
|
|
400 |
}
|
|
401 |
}
|
|
402 |
|
|
403 |
//
|
|
404 |
// DocumentEvent methods
|
|
405 |
//
|
|
406 |
|
|
407 |
/**
|
|
408 |
* Introduced in DOM Level 2. Optional. <p>
|
|
409 |
* Create and return Event objects.
|
|
410 |
*
|
|
411 |
* @param type The eventType parameter specifies the type of Event
|
|
412 |
* interface to be created. If the Event interface specified is supported
|
|
413 |
* by the implementation this method will return a new Event of the
|
|
414 |
* interface type requested. If the Event is to be dispatched via the
|
|
415 |
* dispatchEvent method the appropriate event init method must be called
|
|
416 |
* after creation in order to initialize the Event's values. As an
|
|
417 |
* example, a user wishing to synthesize some kind of Event would call
|
|
418 |
* createEvent with the parameter "Events". The initEvent method could then
|
|
419 |
* be called on the newly created Event to set the specific type of Event
|
|
420 |
* to be dispatched and set its context information.
|
|
421 |
* @return Newly created Event
|
|
422 |
* @exception DOMException NOT_SUPPORTED_ERR: Raised if the implementation
|
|
423 |
* does not support the type of Event interface requested
|
|
424 |
* @since WD-DOM-Level-2-19990923
|
|
425 |
*/
|
|
426 |
public Event createEvent(String type)
|
|
427 |
throws DOMException {
|
|
428 |
if (type.equalsIgnoreCase("Events") || "Event".equals(type))
|
|
429 |
return new EventImpl();
|
|
430 |
if (type.equalsIgnoreCase("MutationEvents") ||
|
|
431 |
"MutationEvent".equals(type))
|
|
432 |
return new MutationEventImpl();
|
|
433 |
else {
|
|
434 |
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NOT_SUPPORTED_ERR", null);
|
|
435 |
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
|
|
436 |
}
|
|
437 |
}
|
|
438 |
|
|
439 |
/**
|
|
440 |
* Sets whether the DOM implementation generates mutation events
|
|
441 |
* upon operations.
|
|
442 |
*/
|
|
443 |
void setMutationEvents(boolean set) {
|
|
444 |
mutationEvents = set;
|
|
445 |
}
|
|
446 |
|
|
447 |
/**
|
|
448 |
* Returns true if the DOM implementation generates mutation events.
|
|
449 |
*/
|
|
450 |
boolean getMutationEvents() {
|
|
451 |
return mutationEvents;
|
|
452 |
}
|
|
453 |
|
|
454 |
/**
|
|
455 |
* Store event listener registered on a given node
|
|
456 |
* This is another place where we could use weak references! Indeed, the
|
|
457 |
* node here won't be GC'ed as long as some listener is registered on it,
|
|
458 |
* since the eventsListeners table will have a reference to the node.
|
|
459 |
*/
|
33349
|
460 |
protected void setEventListeners(NodeImpl n, List<LEntry> listeners) {
|
12005
|
461 |
if (eventListeners == null) {
|
33349
|
462 |
eventListeners = new HashMap<>();
|
12005
|
463 |
}
|
|
464 |
if (listeners == null) {
|
|
465 |
eventListeners.remove(n);
|
|
466 |
if (eventListeners.isEmpty()) {
|
|
467 |
// stop firing events when there isn't any listener
|
|
468 |
mutationEvents = false;
|
|
469 |
}
|
|
470 |
} else {
|
|
471 |
eventListeners.put(n, listeners);
|
|
472 |
// turn mutation events on
|
|
473 |
mutationEvents = true;
|
|
474 |
}
|
|
475 |
}
|
|
476 |
|
|
477 |
/**
|
|
478 |
* Retreive event listener registered on a given node
|
|
479 |
*/
|
33349
|
480 |
protected List getEventListeners(NodeImpl n) {
|
12005
|
481 |
if (eventListeners == null) {
|
|
482 |
return null;
|
|
483 |
}
|
33349
|
484 |
return eventListeners.get(n);
|
12005
|
485 |
}
|
|
486 |
|
|
487 |
//
|
|
488 |
// EventTarget support (public and internal)
|
|
489 |
//
|
|
490 |
|
|
491 |
//
|
|
492 |
// Constants
|
|
493 |
//
|
|
494 |
|
|
495 |
/*
|
|
496 |
* NON-DOM INTERNAL: Class LEntry is just a struct used to represent
|
|
497 |
* event listeners registered with this node. Copies of this object
|
|
498 |
* are hung from the nodeListeners Vector.
|
|
499 |
* <p>
|
|
500 |
* I considered using two vectors -- one for capture,
|
|
501 |
* one for bubble -- but decided that since the list of listeners
|
|
502 |
* is probably short in most cases, it might not be worth spending
|
|
503 |
* the space. ***** REVISIT WHEN WE HAVE MORE EXPERIENCE.
|
|
504 |
*/
|
|
505 |
class LEntry implements Serializable {
|
|
506 |
|
|
507 |
private static final long serialVersionUID = -8426757059492421631L;
|
|
508 |
String type;
|
|
509 |
EventListener listener;
|
|
510 |
boolean useCapture;
|
|
511 |
|
|
512 |
/** NON-DOM INTERNAL: Constructor for Listener list Entry
|
|
513 |
* @param type Event name (NOT event group!) to listen for.
|
|
514 |
* @param listener Who gets called when event is dispatched
|
|
515 |
* @param useCaptue True iff listener is registered on
|
|
516 |
* capturing phase rather than at-target or bubbling
|
|
517 |
*/
|
|
518 |
LEntry(String type, EventListener listener, boolean useCapture)
|
|
519 |
{
|
|
520 |
this.type = type;
|
|
521 |
this.listener = listener;
|
|
522 |
this.useCapture = useCapture;
|
|
523 |
}
|
|
524 |
|
|
525 |
} // LEntry
|
|
526 |
|
|
527 |
/**
|
|
528 |
* Introduced in DOM Level 2. <p> Register an event listener with this
|
|
529 |
* Node. A listener may be independently registered as both Capturing and
|
|
530 |
* Bubbling, but may only be registered once per role; redundant
|
|
531 |
* registrations are ignored.
|
|
532 |
* @param node node to add listener to
|
|
533 |
* @param type Event name (NOT event group!) to listen for.
|
|
534 |
* @param listener Who gets called when event is dispatched
|
|
535 |
* @param useCapture True iff listener is registered on
|
|
536 |
* capturing phase rather than at-target or bubbling
|
|
537 |
*/
|
33349
|
538 |
@Override
|
12005
|
539 |
protected void addEventListener(NodeImpl node, String type,
|
|
540 |
EventListener listener, boolean useCapture)
|
|
541 |
{
|
|
542 |
// We can't dispatch to blank type-name, and of course we need
|
|
543 |
// a listener to dispatch to
|
|
544 |
if (type == null || type.equals("") || listener == null)
|
|
545 |
return;
|
|
546 |
|
|
547 |
// Each listener may be registered only once per type per phase.
|
|
548 |
// Simplest way to code that is to zap the previous entry, if any.
|
|
549 |
removeEventListener(node, type, listener, useCapture);
|
|
550 |
|
33349
|
551 |
List<LEntry> nodeListeners = getEventListeners(node);
|
12005
|
552 |
if(nodeListeners == null) {
|
33349
|
553 |
nodeListeners = new ArrayList<>();
|
12005
|
554 |
setEventListeners(node, nodeListeners);
|
|
555 |
}
|
33349
|
556 |
nodeListeners.add(new LEntry(type, listener, useCapture));
|
12005
|
557 |
|
|
558 |
// Record active listener
|
|
559 |
LCount lc = LCount.lookup(type);
|
|
560 |
if (useCapture) {
|
|
561 |
++lc.captures;
|
|
562 |
++lc.total;
|
|
563 |
}
|
|
564 |
else {
|
|
565 |
++lc.bubbles;
|
|
566 |
++lc.total;
|
|
567 |
}
|
|
568 |
|
|
569 |
} // addEventListener(NodeImpl,String,EventListener,boolean) :void
|
|
570 |
|
|
571 |
/**
|
|
572 |
* Introduced in DOM Level 2. <p> Deregister an event listener previously
|
|
573 |
* registered with this Node. A listener must be independently removed
|
|
574 |
* from the Capturing and Bubbling roles. Redundant removals (of listeners
|
|
575 |
* not currently registered for this role) are ignored.
|
|
576 |
* @param node node to remove listener from
|
|
577 |
* @param type Event name (NOT event group!) to listen for.
|
|
578 |
* @param listener Who gets called when event is dispatched
|
|
579 |
* @param useCapture True iff listener is registered on
|
|
580 |
* capturing phase rather than at-target or bubbling
|
|
581 |
*/
|
33349
|
582 |
@Override
|
12005
|
583 |
protected void removeEventListener(NodeImpl node, String type,
|
|
584 |
EventListener listener,
|
|
585 |
boolean useCapture)
|
|
586 |
{
|
|
587 |
// If this couldn't be a valid listener registration, ignore request
|
|
588 |
if (type == null || type.equals("") || listener == null)
|
|
589 |
return;
|
33349
|
590 |
List<LEntry> nodeListeners = getEventListeners(node);
|
12005
|
591 |
if (nodeListeners == null)
|
|
592 |
return;
|
|
593 |
|
|
594 |
// Note that addListener has previously ensured that
|
|
595 |
// each listener may be registered only once per type per phase.
|
|
596 |
// count-down is OK for deletions!
|
|
597 |
for (int i = nodeListeners.size() - 1; i >= 0; --i) {
|
33349
|
598 |
LEntry le = nodeListeners.get(i);
|
12005
|
599 |
if (le.useCapture == useCapture && le.listener == listener &&
|
|
600 |
le.type.equals(type)) {
|
33349
|
601 |
nodeListeners.remove(i);
|
12005
|
602 |
// Storage management: Discard empty listener lists
|
33349
|
603 |
if (nodeListeners.isEmpty())
|
12005
|
604 |
setEventListeners(node, null);
|
|
605 |
|
|
606 |
// Remove active listener
|
|
607 |
LCount lc = LCount.lookup(type);
|
|
608 |
if (useCapture) {
|
|
609 |
--lc.captures;
|
|
610 |
--lc.total;
|
|
611 |
}
|
|
612 |
else {
|
|
613 |
--lc.bubbles;
|
|
614 |
--lc.total;
|
|
615 |
}
|
|
616 |
|
|
617 |
break; // Found it; no need to loop farther.
|
|
618 |
}
|
|
619 |
}
|
|
620 |
} // removeEventListener(NodeImpl,String,EventListener,boolean) :void
|
|
621 |
|
33349
|
622 |
@Override
|
12005
|
623 |
protected void copyEventListeners(NodeImpl src, NodeImpl tgt) {
|
33349
|
624 |
List<LEntry> nodeListeners = getEventListeners(src);
|
12005
|
625 |
if (nodeListeners == null) {
|
|
626 |
return;
|
|
627 |
}
|
33349
|
628 |
setEventListeners(tgt, new ArrayList<>(nodeListeners));
|
12005
|
629 |
}
|
|
630 |
|
|
631 |
/**
|
|
632 |
* Introduced in DOM Level 2. <p>
|
|
633 |
* Distribution engine for DOM Level 2 Events.
|
|
634 |
* <p>
|
|
635 |
* Event propagation runs as follows:
|
|
636 |
* <ol>
|
|
637 |
* <li>Event is dispatched to a particular target node, which invokes
|
|
638 |
* this code. Note that the event's stopPropagation flag is
|
|
639 |
* cleared when dispatch begins; thereafter, if it has
|
|
640 |
* been set before processing of a node commences, we instead
|
|
641 |
* immediately advance to the DEFAULT phase.
|
|
642 |
* <li>The node's ancestors are established as destinations for events.
|
|
643 |
* For capture and bubble purposes, node ancestry is determined at
|
|
644 |
* the time dispatch starts. If an event handler alters the document
|
|
645 |
* tree, that does not change which nodes will be informed of the event.
|
|
646 |
* <li>CAPTURING_PHASE: Ancestors are scanned, root to target, for
|
|
647 |
* Capturing listeners. If found, they are invoked (see below).
|
|
648 |
* <li>AT_TARGET:
|
|
649 |
* Event is dispatched to NON-CAPTURING listeners on the
|
|
650 |
* target node. Note that capturing listeners on this node are _not_
|
|
651 |
* invoked.
|
|
652 |
* <li>BUBBLING_PHASE: Ancestors are scanned, target to root, for
|
|
653 |
* non-capturing listeners.
|
|
654 |
* <li>Default processing: Some DOMs have default behaviors bound to
|
|
655 |
* specific nodes. If this DOM does, and if the event's preventDefault
|
|
656 |
* flag has not been set, we now return to the target node and process
|
|
657 |
* its default handler for this event, if any.
|
|
658 |
* </ol>
|
|
659 |
* <p>
|
|
660 |
* Note that registration of handlers during processing of an event does
|
|
661 |
* not take effect during this phase of this event; they will not be called
|
|
662 |
* until the next time this node is visited by dispatchEvent. On the other
|
|
663 |
* hand, removals take effect immediately.
|
|
664 |
* <p>
|
|
665 |
* If an event handler itself causes events to be dispatched, they are
|
|
666 |
* processed synchronously, before processing resumes
|
|
667 |
* on the event which triggered them. Please be aware that this may
|
|
668 |
* result in events arriving at listeners "out of order" relative
|
|
669 |
* to the actual sequence of requests.
|
|
670 |
* <p>
|
|
671 |
* Note that our implementation resets the event's stop/prevent flags
|
|
672 |
* when dispatch begins.
|
|
673 |
* I believe the DOM's intent is that event objects be redispatchable,
|
|
674 |
* though it isn't stated in those terms.
|
|
675 |
* @param node node to dispatch to
|
|
676 |
* @param event the event object to be dispatched to
|
|
677 |
* registered EventListeners
|
|
678 |
* @return true if the event's <code>preventDefault()</code>
|
|
679 |
* method was invoked by an EventListener; otherwise false.
|
|
680 |
*/
|
33349
|
681 |
@Override
|
12005
|
682 |
protected boolean dispatchEvent(NodeImpl node, Event event) {
|
|
683 |
if (event == null) return false;
|
|
684 |
|
|
685 |
// Can't use anyone else's implementation, since there's no public
|
|
686 |
// API for setting the event's processing-state fields.
|
|
687 |
EventImpl evt = (EventImpl)event;
|
|
688 |
|
|
689 |
// VALIDATE -- must have been initialized at least once, must have
|
|
690 |
// a non-null non-blank name.
|
|
691 |
if(!evt.initialized || evt.type == null || evt.type.equals("")) {
|
|
692 |
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "UNSPECIFIED_EVENT_TYPE_ERR", null);
|
|
693 |
throw new EventException(EventException.UNSPECIFIED_EVENT_TYPE_ERR, msg);
|
|
694 |
}
|
|
695 |
|
|
696 |
// If nobody is listening for this event, discard immediately
|
|
697 |
LCount lc = LCount.lookup(evt.getType());
|
|
698 |
if (lc.total == 0)
|
|
699 |
return evt.preventDefault;
|
|
700 |
|
|
701 |
// INITIALIZE THE EVENT'S DISPATCH STATUS
|
|
702 |
// (Note that Event objects are reusable in our implementation;
|
|
703 |
// that doesn't seem to be explicitly guaranteed in the DOM, but
|
|
704 |
// I believe it is the intent.)
|
|
705 |
evt.target = node;
|
|
706 |
evt.stopPropagation = false;
|
|
707 |
evt.preventDefault = false;
|
|
708 |
|
|
709 |
// Capture pre-event parentage chain, not including target;
|
|
710 |
// use pre-event-dispatch ancestors even if event handlers mutate
|
|
711 |
// document and change the target's context.
|
|
712 |
// Note that this is parents ONLY; events do not
|
|
713 |
// cross the Attr/Element "blood/brain barrier".
|
|
714 |
// DOMAttrModified. which looks like an exception,
|
|
715 |
// is issued to the Element rather than the Attr
|
|
716 |
// and causes a _second_ DOMSubtreeModified in the Element's
|
|
717 |
// tree.
|
33349
|
718 |
List<Node> pv = new ArrayList<>(10);
|
12005
|
719 |
Node p = node;
|
|
720 |
Node n = p.getParentNode();
|
|
721 |
while (n != null) {
|
33349
|
722 |
pv.add(n);
|
12005
|
723 |
p = n;
|
|
724 |
n = n.getParentNode();
|
|
725 |
}
|
|
726 |
|
|
727 |
// CAPTURING_PHASE:
|
|
728 |
if (lc.captures > 0) {
|
|
729 |
evt.eventPhase = Event.CAPTURING_PHASE;
|
|
730 |
// Ancestors are scanned, root to target, for
|
|
731 |
// Capturing listeners.
|
|
732 |
for (int j = pv.size() - 1; j >= 0; --j) {
|
|
733 |
if (evt.stopPropagation)
|
|
734 |
break; // Someone set the flag. Phase ends.
|
|
735 |
|
|
736 |
// Handle all capturing listeners on this node
|
33349
|
737 |
NodeImpl nn = (NodeImpl) pv.get(j);
|
12005
|
738 |
evt.currentTarget = nn;
|
33349
|
739 |
List<LEntry> nodeListeners = getEventListeners(nn);
|
12005
|
740 |
if (nodeListeners != null) {
|
33349
|
741 |
List<LEntry> nl = (List)((ArrayList)nodeListeners).clone();
|
12005
|
742 |
// call listeners in the order in which they got registered
|
|
743 |
int nlsize = nl.size();
|
|
744 |
for (int i = 0; i < nlsize; i++) {
|
33349
|
745 |
LEntry le = nl.get(i);
|
12005
|
746 |
if (le.useCapture && le.type.equals(evt.type) &&
|
|
747 |
nodeListeners.contains(le)) {
|
|
748 |
try {
|
|
749 |
le.listener.handleEvent(evt);
|
|
750 |
}
|
|
751 |
catch (Exception e) {
|
|
752 |
// All exceptions are ignored.
|
|
753 |
}
|
|
754 |
}
|
|
755 |
}
|
|
756 |
}
|
|
757 |
}
|
|
758 |
}
|
|
759 |
|
|
760 |
|
|
761 |
// Both AT_TARGET and BUBBLE use non-capturing listeners.
|
|
762 |
if (lc.bubbles > 0) {
|
|
763 |
// AT_TARGET PHASE: Event is dispatched to NON-CAPTURING listeners
|
|
764 |
// on the target node. Note that capturing listeners on the target
|
|
765 |
// node are _not_ invoked, even during the capture phase.
|
|
766 |
evt.eventPhase = Event.AT_TARGET;
|
|
767 |
evt.currentTarget = node;
|
33349
|
768 |
List<LEntry> nodeListeners = getEventListeners(node);
|
12005
|
769 |
if (!evt.stopPropagation && nodeListeners != null) {
|
33349
|
770 |
List<LEntry> nl = (List)((ArrayList)nodeListeners).clone();
|
12005
|
771 |
// call listeners in the order in which they got registered
|
|
772 |
int nlsize = nl.size();
|
|
773 |
for (int i = 0; i < nlsize; i++) {
|
33349
|
774 |
LEntry le = (LEntry) nl.get(i);
|
12005
|
775 |
if (!le.useCapture && le.type.equals(evt.type) &&
|
|
776 |
nodeListeners.contains(le)) {
|
|
777 |
try {
|
|
778 |
le.listener.handleEvent(evt);
|
|
779 |
}
|
|
780 |
catch (Exception e) {
|
|
781 |
// All exceptions are ignored.
|
|
782 |
}
|
|
783 |
}
|
|
784 |
}
|
|
785 |
}
|
|
786 |
// BUBBLING_PHASE: Ancestors are scanned, target to root, for
|
|
787 |
// non-capturing listeners. If the event's preventBubbling flag
|
|
788 |
// has been set before processing of a node commences, we
|
|
789 |
// instead immediately advance to the default phase.
|
|
790 |
// Note that not all events bubble.
|
|
791 |
if (evt.bubbles) {
|
|
792 |
evt.eventPhase = Event.BUBBLING_PHASE;
|
|
793 |
int pvsize = pv.size();
|
|
794 |
for (int j = 0; j < pvsize; j++) {
|
|
795 |
if (evt.stopPropagation)
|
|
796 |
break; // Someone set the flag. Phase ends.
|
|
797 |
|
|
798 |
// Handle all bubbling listeners on this node
|
33349
|
799 |
NodeImpl nn = (NodeImpl) pv.get(j);
|
12005
|
800 |
evt.currentTarget = nn;
|
|
801 |
nodeListeners = getEventListeners(nn);
|
|
802 |
if (nodeListeners != null) {
|
33349
|
803 |
List<LEntry> nl = (List)((ArrayList)nodeListeners).clone();
|
12005
|
804 |
// call listeners in the order in which they got
|
|
805 |
// registered
|
|
806 |
int nlsize = nl.size();
|
|
807 |
for (int i = 0; i < nlsize; i++) {
|
33349
|
808 |
LEntry le = nl.get(i);
|
12005
|
809 |
if (!le.useCapture && le.type.equals(evt.type) &&
|
|
810 |
nodeListeners.contains(le)) {
|
|
811 |
try {
|
|
812 |
le.listener.handleEvent(evt);
|
|
813 |
}
|
|
814 |
catch (Exception e) {
|
|
815 |
// All exceptions are ignored.
|
|
816 |
}
|
|
817 |
}
|
|
818 |
}
|
|
819 |
}
|
|
820 |
}
|
|
821 |
}
|
|
822 |
}
|
|
823 |
|
|
824 |
// DEFAULT PHASE: Some DOMs have default behaviors bound to specific
|
|
825 |
// nodes. If this DOM does, and if the event's preventDefault flag has
|
|
826 |
// not been set, we now return to the target node and process its
|
|
827 |
// default handler for this event, if any.
|
|
828 |
// No specific phase value defined, since this is DOM-internal
|
|
829 |
if (lc.defaults > 0 && (!evt.cancelable || !evt.preventDefault)) {
|
|
830 |
// evt.eventPhase = Event.DEFAULT_PHASE;
|
|
831 |
// evt.currentTarget = node;
|
|
832 |
// DO_DEFAULT_OPERATION
|
|
833 |
}
|
|
834 |
|
|
835 |
return evt.preventDefault;
|
|
836 |
} // dispatchEvent(NodeImpl,Event) :boolean
|
|
837 |
|
|
838 |
/**
|
|
839 |
* NON-DOM INTERNAL: DOMNodeInsertedIntoDocument and ...RemovedFrom...
|
|
840 |
* are dispatched to an entire subtree. This is the distribution code
|
|
841 |
* therefor. They DO NOT bubble, thanks be, but may be captured.
|
|
842 |
* <p>
|
|
843 |
* Similar to code in dispatchingEventToSubtree however this method
|
|
844 |
* is only used on the target node and does not start a dispatching chain
|
|
845 |
* on the sibling of the target node as this is not part of the subtree
|
|
846 |
* ***** At the moment I'm being sloppy and using the normal
|
|
847 |
* capture dispatcher on every node. This could be optimized hugely
|
|
848 |
* by writing a capture engine that tracks our position in the tree to
|
|
849 |
* update the capture chain without repeated chases up to root.
|
|
850 |
* @param n target node (that was directly inserted or removed)
|
|
851 |
* @param e event to be sent to that node and its subtree
|
|
852 |
*/
|
|
853 |
protected void dispatchEventToSubtree(Node n, Event e) {
|
|
854 |
|
|
855 |
((NodeImpl) n).dispatchEvent(e);
|
|
856 |
if (n.getNodeType() == Node.ELEMENT_NODE) {
|
|
857 |
NamedNodeMap a = n.getAttributes();
|
|
858 |
for (int i = a.getLength() - 1; i >= 0; --i)
|
|
859 |
dispatchingEventToSubtree(a.item(i), e);
|
|
860 |
}
|
|
861 |
dispatchingEventToSubtree(n.getFirstChild(), e);
|
|
862 |
|
|
863 |
} // dispatchEventToSubtree(NodeImpl,Node,Event) :void
|
|
864 |
|
|
865 |
|
|
866 |
/**
|
|
867 |
* Dispatches event to the target node's descendents recursively
|
|
868 |
*
|
|
869 |
* @param n node to dispatch to
|
|
870 |
* @param e event to be sent to that node and its subtree
|
|
871 |
*/
|
|
872 |
protected void dispatchingEventToSubtree(Node n, Event e) {
|
|
873 |
if (n==null)
|
|
874 |
return;
|
|
875 |
|
|
876 |
// ***** Recursive implementation. This is excessively expensive,
|
|
877 |
// and should be replaced in conjunction with optimization
|
|
878 |
// mentioned above.
|
|
879 |
((NodeImpl) n).dispatchEvent(e);
|
|
880 |
if (n.getNodeType() == Node.ELEMENT_NODE) {
|
|
881 |
NamedNodeMap a = n.getAttributes();
|
|
882 |
for (int i = a.getLength() - 1; i >= 0; --i)
|
|
883 |
dispatchingEventToSubtree(a.item(i), e);
|
|
884 |
}
|
|
885 |
dispatchingEventToSubtree(n.getFirstChild(), e);
|
|
886 |
dispatchingEventToSubtree(n.getNextSibling(), e);
|
|
887 |
}
|
|
888 |
|
|
889 |
/**
|
|
890 |
* NON-DOM INTERNAL: Return object for getEnclosingAttr. Carries
|
|
891 |
* (two values, the Attr node affected (if any) and its previous
|
|
892 |
* string value. Simple struct, no methods.
|
|
893 |
*/
|
|
894 |
class EnclosingAttr implements Serializable {
|
|
895 |
private static final long serialVersionUID = 5208387723391647216L;
|
|
896 |
AttrImpl node;
|
|
897 |
String oldvalue;
|
|
898 |
}
|
|
899 |
|
|
900 |
EnclosingAttr savedEnclosingAttr;
|
|
901 |
|
|
902 |
/**
|
|
903 |
* NON-DOM INTERNAL: Convenience wrapper for calling
|
|
904 |
* dispatchAggregateEvents when the context was established
|
|
905 |
* by <code>savedEnclosingAttr</code>.
|
|
906 |
* @param node node to dispatch to
|
|
907 |
* @param ea description of Attr affected by current operation
|
|
908 |
*/
|
|
909 |
protected void dispatchAggregateEvents(NodeImpl node, EnclosingAttr ea) {
|
|
910 |
if (ea != null)
|
|
911 |
dispatchAggregateEvents(node, ea.node, ea.oldvalue,
|
|
912 |
MutationEvent.MODIFICATION);
|
|
913 |
else
|
|
914 |
dispatchAggregateEvents(node, null, null, (short) 0);
|
|
915 |
|
|
916 |
} // dispatchAggregateEvents(NodeImpl,EnclosingAttr) :void
|
|
917 |
|
|
918 |
/**
|
|
919 |
* NON-DOM INTERNAL: Generate the "aggregated" post-mutation events
|
|
920 |
* DOMAttrModified and DOMSubtreeModified.
|
|
921 |
* Both of these should be issued only once for each user-requested
|
|
922 |
* mutation operation, even if that involves multiple changes to
|
|
923 |
* the DOM.
|
|
924 |
* For example, if a DOM operation makes multiple changes to a single
|
|
925 |
* Attr before returning, it would be nice to generate only one
|
|
926 |
* DOMAttrModified, and multiple changes over larger scope but within
|
|
927 |
* a recognizable single subtree might want to generate only one
|
|
928 |
* DOMSubtreeModified, sent to their lowest common ancestor.
|
|
929 |
* <p>
|
|
930 |
* To manage this, use the "internal" versions of insert and remove
|
|
931 |
* with MUTATION_LOCAL, then make an explicit call to this routine
|
|
932 |
* at the higher level. Some examples now exist in our code.
|
|
933 |
*
|
|
934 |
* @param node The node to dispatch to
|
|
935 |
* @param enclosingAttr The Attr node (if any) whose value has been changed
|
|
936 |
* as a result of the DOM operation. Null if none such.
|
|
937 |
* @param oldValue The String value previously held by the
|
|
938 |
* enclosingAttr. Ignored if none such.
|
|
939 |
* @param change Type of modification to the attr. See
|
|
940 |
* MutationEvent.attrChange
|
|
941 |
*/
|
|
942 |
protected void dispatchAggregateEvents(NodeImpl node,
|
|
943 |
AttrImpl enclosingAttr,
|
|
944 |
String oldvalue, short change) {
|
|
945 |
// We have to send DOMAttrModified.
|
|
946 |
NodeImpl owner = null;
|
|
947 |
if (enclosingAttr != null) {
|
|
948 |
LCount lc = LCount.lookup(MutationEventImpl.DOM_ATTR_MODIFIED);
|
|
949 |
owner = (NodeImpl) enclosingAttr.getOwnerElement();
|
|
950 |
if (lc.total > 0) {
|
|
951 |
if (owner != null) {
|
|
952 |
MutationEventImpl me = new MutationEventImpl();
|
|
953 |
me.initMutationEvent(MutationEventImpl.DOM_ATTR_MODIFIED,
|
|
954 |
true, false, enclosingAttr,
|
|
955 |
oldvalue,
|
|
956 |
enclosingAttr.getNodeValue(),
|
|
957 |
enclosingAttr.getNodeName(),
|
|
958 |
change);
|
|
959 |
owner.dispatchEvent(me);
|
|
960 |
}
|
|
961 |
}
|
|
962 |
}
|
|
963 |
// DOMSubtreeModified gets sent to the lowest common root of a
|
|
964 |
// set of changes.
|
|
965 |
// "This event is dispatched after all other events caused by the
|
|
966 |
// mutation have been fired."
|
|
967 |
LCount lc = LCount.lookup(MutationEventImpl.DOM_SUBTREE_MODIFIED);
|
|
968 |
if (lc.total > 0) {
|
|
969 |
MutationEvent me = new MutationEventImpl();
|
|
970 |
me.initMutationEvent(MutationEventImpl.DOM_SUBTREE_MODIFIED,
|
|
971 |
true, false, null, null,
|
|
972 |
null, null, (short) 0);
|
|
973 |
|
|
974 |
// If we're within an Attr, DStM gets sent to the Attr
|
|
975 |
// and to its owningElement. Otherwise we dispatch it
|
|
976 |
// locally.
|
|
977 |
if (enclosingAttr != null) {
|
|
978 |
dispatchEvent(enclosingAttr, me);
|
|
979 |
if (owner != null)
|
|
980 |
dispatchEvent(owner, me);
|
|
981 |
}
|
|
982 |
else
|
|
983 |
dispatchEvent(node, me);
|
|
984 |
}
|
|
985 |
} // dispatchAggregateEvents(NodeImpl, AttrImpl,String) :void
|
|
986 |
|
|
987 |
/**
|
|
988 |
* NON-DOM INTERNAL: Pre-mutation context check, in
|
|
989 |
* preparation for later generating DOMAttrModified events.
|
|
990 |
* Determines whether this node is within an Attr
|
|
991 |
* @param node node to get enclosing attribute for
|
|
992 |
* @return either a description of that Attr, or null if none such.
|
|
993 |
*/
|
|
994 |
protected void saveEnclosingAttr(NodeImpl node) {
|
|
995 |
savedEnclosingAttr = null;
|
|
996 |
// MUTATION PREPROCESSING AND PRE-EVENTS:
|
|
997 |
// If we're within the scope of an Attr and DOMAttrModified
|
|
998 |
// was requested, we need to preserve its previous value for
|
|
999 |
// that event.
|
|
1000 |
LCount lc = LCount.lookup(MutationEventImpl.DOM_ATTR_MODIFIED);
|
|
1001 |
if (lc.total > 0) {
|
|
1002 |
NodeImpl eventAncestor = node;
|
|
1003 |
while (true) {
|
|
1004 |
if (eventAncestor == null)
|
|
1005 |
return;
|
|
1006 |
int type = eventAncestor.getNodeType();
|
|
1007 |
if (type == Node.ATTRIBUTE_NODE) {
|
|
1008 |
EnclosingAttr retval = new EnclosingAttr();
|
|
1009 |
retval.node = (AttrImpl) eventAncestor;
|
|
1010 |
retval.oldvalue = retval.node.getNodeValue();
|
|
1011 |
savedEnclosingAttr = retval;
|
|
1012 |
return;
|
|
1013 |
}
|
|
1014 |
else if (type == Node.ENTITY_REFERENCE_NODE)
|
|
1015 |
eventAncestor = eventAncestor.parentNode();
|
|
1016 |
else if (type == Node.TEXT_NODE)
|
|
1017 |
eventAncestor = eventAncestor.parentNode();
|
|
1018 |
else
|
|
1019 |
return;
|
|
1020 |
// Any other parent means we're not in an Attr
|
|
1021 |
}
|
|
1022 |
}
|
|
1023 |
} // saveEnclosingAttr(NodeImpl) :void
|
|
1024 |
|
|
1025 |
/**
|
|
1026 |
* A method to be called when a character data node has been modified
|
|
1027 |
*/
|
|
1028 |
void modifyingCharacterData(NodeImpl node, boolean replace) {
|
|
1029 |
if (mutationEvents) {
|
|
1030 |
if (!replace) {
|
|
1031 |
saveEnclosingAttr(node);
|
|
1032 |
}
|
|
1033 |
}
|
|
1034 |
}
|
|
1035 |
|
|
1036 |
/**
|
|
1037 |
* A method to be called when a character data node has been modified
|
|
1038 |
*/
|
|
1039 |
void modifiedCharacterData(NodeImpl node, String oldvalue, String value, boolean replace) {
|
|
1040 |
if (mutationEvents) {
|
|
1041 |
if (!replace) {
|
|
1042 |
// MUTATION POST-EVENTS:
|
|
1043 |
LCount lc =
|
|
1044 |
LCount.lookup(MutationEventImpl.DOM_CHARACTER_DATA_MODIFIED);
|
|
1045 |
if (lc.total > 0) {
|
|
1046 |
MutationEvent me = new MutationEventImpl();
|
|
1047 |
me.initMutationEvent(
|
|
1048 |
MutationEventImpl.DOM_CHARACTER_DATA_MODIFIED,
|
|
1049 |
true, false, null,
|
|
1050 |
oldvalue, value, null, (short) 0);
|
|
1051 |
dispatchEvent(node, me);
|
|
1052 |
}
|
|
1053 |
|
|
1054 |
// Subroutine: Transmit DOMAttrModified and DOMSubtreeModified,
|
|
1055 |
// if required. (Common to most kinds of mutation)
|
|
1056 |
dispatchAggregateEvents(node, savedEnclosingAttr);
|
|
1057 |
} // End mutation postprocessing
|
|
1058 |
}
|
|
1059 |
}
|
|
1060 |
|
|
1061 |
/**
|
|
1062 |
* A method to be called when a character data node has been replaced
|
|
1063 |
*/
|
|
1064 |
void replacedCharacterData(NodeImpl node, String oldvalue, String value) {
|
|
1065 |
//now that we have finished replacing data, we need to perform the same actions
|
|
1066 |
//that are required after a character data node has been modified
|
|
1067 |
//send the value of false for replace parameter so that mutation
|
|
1068 |
//events if appropriate will be initiated
|
|
1069 |
modifiedCharacterData(node, oldvalue, value, false);
|
|
1070 |
}
|
|
1071 |
|
|
1072 |
|
|
1073 |
|
|
1074 |
/**
|
|
1075 |
* A method to be called when a node is about to be inserted in the tree.
|
|
1076 |
*/
|
|
1077 |
void insertingNode(NodeImpl node, boolean replace) {
|
|
1078 |
if (mutationEvents) {
|
|
1079 |
if (!replace) {
|
|
1080 |
saveEnclosingAttr(node);
|
|
1081 |
}
|
|
1082 |
}
|
|
1083 |
}
|
|
1084 |
|
|
1085 |
/**
|
|
1086 |
* A method to be called when a node has been inserted in the tree.
|
|
1087 |
*/
|
|
1088 |
void insertedNode(NodeImpl node, NodeImpl newInternal, boolean replace) {
|
|
1089 |
if (mutationEvents) {
|
|
1090 |
// MUTATION POST-EVENTS:
|
|
1091 |
// "Local" events (non-aggregated)
|
|
1092 |
// New child is told it was inserted, and where
|
|
1093 |
LCount lc = LCount.lookup(MutationEventImpl.DOM_NODE_INSERTED);
|
|
1094 |
if (lc.total > 0) {
|
|
1095 |
MutationEventImpl me = new MutationEventImpl();
|
|
1096 |
me.initMutationEvent(MutationEventImpl.DOM_NODE_INSERTED,
|
|
1097 |
true, false, node,
|
|
1098 |
null, null, null, (short) 0);
|
|
1099 |
dispatchEvent(newInternal, me);
|
|
1100 |
}
|
|
1101 |
|
|
1102 |
// If within the Document, tell the subtree it's been added
|
|
1103 |
// to the Doc.
|
|
1104 |
lc = LCount.lookup(
|
|
1105 |
MutationEventImpl.DOM_NODE_INSERTED_INTO_DOCUMENT);
|
|
1106 |
if (lc.total > 0) {
|
|
1107 |
NodeImpl eventAncestor = node;
|
|
1108 |
if (savedEnclosingAttr != null)
|
|
1109 |
eventAncestor = (NodeImpl)
|
|
1110 |
savedEnclosingAttr.node.getOwnerElement();
|
|
1111 |
if (eventAncestor != null) { // Might have been orphan Attr
|
|
1112 |
NodeImpl p = eventAncestor;
|
|
1113 |
while (p != null) {
|
|
1114 |
eventAncestor = p; // Last non-null ancestor
|
|
1115 |
// In this context, ancestry includes
|
|
1116 |
// walking back from Attr to Element
|
|
1117 |
if (p.getNodeType() == ATTRIBUTE_NODE) {
|
|
1118 |
p = (NodeImpl) ((AttrImpl)p).getOwnerElement();
|
|
1119 |
}
|
|
1120 |
else {
|
|
1121 |
p = p.parentNode();
|
|
1122 |
}
|
|
1123 |
}
|
|
1124 |
if (eventAncestor.getNodeType() == Node.DOCUMENT_NODE){
|
|
1125 |
MutationEventImpl me = new MutationEventImpl();
|
|
1126 |
me.initMutationEvent(MutationEventImpl
|
|
1127 |
.DOM_NODE_INSERTED_INTO_DOCUMENT,
|
|
1128 |
false,false,null,null,
|
|
1129 |
null,null,(short)0);
|
|
1130 |
dispatchEventToSubtree(newInternal, me);
|
|
1131 |
}
|
|
1132 |
}
|
|
1133 |
}
|
|
1134 |
if (!replace) {
|
|
1135 |
// Subroutine: Transmit DOMAttrModified and DOMSubtreeModified
|
|
1136 |
// (Common to most kinds of mutation)
|
|
1137 |
dispatchAggregateEvents(node, savedEnclosingAttr);
|
|
1138 |
}
|
|
1139 |
}
|
|
1140 |
|
|
1141 |
// notify the range of insertions
|
|
1142 |
if (ranges != null) {
|
|
1143 |
int size = ranges.size();
|
|
1144 |
for (int i = 0; i != size; i++) {
|
33349
|
1145 |
((RangeImpl)ranges.get(i)).insertedNodeFromDOM(newInternal);
|
12005
|
1146 |
}
|
|
1147 |
}
|
|
1148 |
}
|
|
1149 |
|
|
1150 |
/**
|
|
1151 |
* A method to be called when a node is about to be removed from the tree.
|
|
1152 |
*/
|
|
1153 |
void removingNode(NodeImpl node, NodeImpl oldChild, boolean replace) {
|
|
1154 |
|
|
1155 |
// notify iterators
|
|
1156 |
if (iterators != null) {
|
|
1157 |
int size = iterators.size();
|
|
1158 |
for (int i = 0; i != size; i++) {
|
33349
|
1159 |
((NodeIteratorImpl)iterators.get(i)).removeNode(oldChild);
|
12005
|
1160 |
}
|
|
1161 |
}
|
|
1162 |
|
|
1163 |
// notify ranges
|
|
1164 |
if (ranges != null) {
|
|
1165 |
int size = ranges.size();
|
|
1166 |
for (int i = 0; i != size; i++) {
|
33349
|
1167 |
((RangeImpl)ranges.get(i)).removeNode(oldChild);
|
12005
|
1168 |
}
|
|
1169 |
}
|
|
1170 |
|
|
1171 |
// mutation events
|
|
1172 |
if (mutationEvents) {
|
|
1173 |
// MUTATION PREPROCESSING AND PRE-EVENTS:
|
|
1174 |
// If we're within the scope of an Attr and DOMAttrModified
|
|
1175 |
// was requested, we need to preserve its previous value for
|
|
1176 |
// that event.
|
|
1177 |
if (!replace) {
|
|
1178 |
saveEnclosingAttr(node);
|
|
1179 |
}
|
|
1180 |
// Child is told that it is about to be removed
|
|
1181 |
LCount lc = LCount.lookup(MutationEventImpl.DOM_NODE_REMOVED);
|
|
1182 |
if (lc.total > 0) {
|
|
1183 |
MutationEventImpl me= new MutationEventImpl();
|
|
1184 |
me.initMutationEvent(MutationEventImpl.DOM_NODE_REMOVED,
|
|
1185 |
true, false, node, null,
|
|
1186 |
null, null, (short) 0);
|
|
1187 |
dispatchEvent(oldChild, me);
|
|
1188 |
}
|
|
1189 |
|
|
1190 |
// If within Document, child's subtree is informed that it's
|
|
1191 |
// losing that status
|
|
1192 |
lc = LCount.lookup(
|
|
1193 |
MutationEventImpl.DOM_NODE_REMOVED_FROM_DOCUMENT);
|
|
1194 |
if (lc.total > 0) {
|
|
1195 |
NodeImpl eventAncestor = this;
|
|
1196 |
if(savedEnclosingAttr != null)
|
|
1197 |
eventAncestor = (NodeImpl)
|
|
1198 |
savedEnclosingAttr.node.getOwnerElement();
|
|
1199 |
if (eventAncestor != null) { // Might have been orphan Attr
|
|
1200 |
for (NodeImpl p = eventAncestor.parentNode();
|
|
1201 |
p != null; p = p.parentNode()) {
|
|
1202 |
eventAncestor = p; // Last non-null ancestor
|
|
1203 |
}
|
|
1204 |
if (eventAncestor.getNodeType() == Node.DOCUMENT_NODE){
|
|
1205 |
MutationEventImpl me = new MutationEventImpl();
|
|
1206 |
me.initMutationEvent(
|
|
1207 |
MutationEventImpl.DOM_NODE_REMOVED_FROM_DOCUMENT,
|
|
1208 |
false, false, null,
|
|
1209 |
null, null, null, (short) 0);
|
|
1210 |
dispatchEventToSubtree(oldChild, me);
|
|
1211 |
}
|
|
1212 |
}
|
|
1213 |
}
|
|
1214 |
} // End mutation preprocessing
|
|
1215 |
}
|
|
1216 |
|
|
1217 |
/**
|
|
1218 |
* A method to be called when a node has been removed from the tree.
|
|
1219 |
*/
|
|
1220 |
void removedNode(NodeImpl node, boolean replace) {
|
|
1221 |
if (mutationEvents) {
|
|
1222 |
// MUTATION POST-EVENTS:
|
|
1223 |
// Subroutine: Transmit DOMAttrModified and DOMSubtreeModified,
|
|
1224 |
// if required. (Common to most kinds of mutation)
|
|
1225 |
if (!replace) {
|
|
1226 |
dispatchAggregateEvents(node, savedEnclosingAttr);
|
|
1227 |
}
|
|
1228 |
} // End mutation postprocessing
|
|
1229 |
}
|
|
1230 |
|
|
1231 |
/**
|
|
1232 |
* A method to be called when a node is about to be replaced in the tree.
|
|
1233 |
*/
|
|
1234 |
void replacingNode(NodeImpl node) {
|
|
1235 |
if (mutationEvents) {
|
|
1236 |
saveEnclosingAttr(node);
|
|
1237 |
}
|
|
1238 |
}
|
|
1239 |
|
|
1240 |
/**
|
|
1241 |
* A method to be called when character data is about to be replaced in the tree.
|
|
1242 |
*/
|
|
1243 |
void replacingData (NodeImpl node) {
|
|
1244 |
if (mutationEvents) {
|
|
1245 |
saveEnclosingAttr(node);
|
|
1246 |
}
|
|
1247 |
}
|
|
1248 |
|
|
1249 |
/**
|
|
1250 |
* A method to be called when a node has been replaced in the tree.
|
|
1251 |
*/
|
|
1252 |
void replacedNode(NodeImpl node) {
|
|
1253 |
if (mutationEvents) {
|
|
1254 |
dispatchAggregateEvents(node, savedEnclosingAttr);
|
|
1255 |
}
|
|
1256 |
}
|
|
1257 |
|
|
1258 |
/**
|
|
1259 |
* A method to be called when an attribute value has been modified
|
|
1260 |
*/
|
|
1261 |
void modifiedAttrValue(AttrImpl attr, String oldvalue) {
|
|
1262 |
if (mutationEvents) {
|
|
1263 |
// MUTATION POST-EVENTS:
|
|
1264 |
dispatchAggregateEvents(attr, attr, oldvalue,
|
|
1265 |
MutationEvent.MODIFICATION);
|
|
1266 |
}
|
|
1267 |
}
|
|
1268 |
|
|
1269 |
/**
|
|
1270 |
* A method to be called when an attribute node has been set
|
|
1271 |
*/
|
|
1272 |
void setAttrNode(AttrImpl attr, AttrImpl previous) {
|
|
1273 |
if (mutationEvents) {
|
|
1274 |
// MUTATION POST-EVENTS:
|
|
1275 |
if (previous == null) {
|
|
1276 |
dispatchAggregateEvents(attr.ownerNode, attr, null,
|
|
1277 |
MutationEvent.ADDITION);
|
|
1278 |
}
|
|
1279 |
else {
|
|
1280 |
dispatchAggregateEvents(attr.ownerNode, attr,
|
|
1281 |
previous.getNodeValue(),
|
|
1282 |
MutationEvent.MODIFICATION);
|
|
1283 |
}
|
|
1284 |
}
|
|
1285 |
}
|
|
1286 |
|
|
1287 |
/**
|
|
1288 |
* A method to be called when an attribute node has been removed
|
|
1289 |
*/
|
|
1290 |
void removedAttrNode(AttrImpl attr, NodeImpl oldOwner, String name) {
|
|
1291 |
// We can't use the standard dispatchAggregate, since it assumes
|
|
1292 |
// that the Attr is still attached to an owner. This code is
|
|
1293 |
// similar but dispatches to the previous owner, "element".
|
|
1294 |
if (mutationEvents) {
|
|
1295 |
// If we have to send DOMAttrModified (determined earlier),
|
|
1296 |
// do so.
|
|
1297 |
LCount lc = LCount.lookup(MutationEventImpl.DOM_ATTR_MODIFIED);
|
|
1298 |
if (lc.total > 0) {
|
|
1299 |
MutationEventImpl me= new MutationEventImpl();
|
|
1300 |
me.initMutationEvent(MutationEventImpl.DOM_ATTR_MODIFIED,
|
|
1301 |
true, false, attr,
|
|
1302 |
attr.getNodeValue(), null, name,
|
|
1303 |
MutationEvent.REMOVAL);
|
|
1304 |
dispatchEvent(oldOwner, me);
|
|
1305 |
}
|
|
1306 |
|
|
1307 |
// We can hand off to process DOMSubtreeModified, though.
|
|
1308 |
// Note that only the Element needs to be informed; the
|
|
1309 |
// Attr's subtree has not been changed by this operation.
|
|
1310 |
dispatchAggregateEvents(oldOwner, null, null, (short) 0);
|
|
1311 |
}
|
|
1312 |
}
|
|
1313 |
|
|
1314 |
|
|
1315 |
/**
|
|
1316 |
* A method to be called when an attribute node has been renamed
|
|
1317 |
*/
|
|
1318 |
void renamedAttrNode(Attr oldAt, Attr newAt) {
|
|
1319 |
// REVISIT: To be implemented!!!
|
|
1320 |
}
|
|
1321 |
|
|
1322 |
/**
|
|
1323 |
* A method to be called when an element has been renamed
|
|
1324 |
*/
|
|
1325 |
void renamedElement(Element oldEl, Element newEl) {
|
|
1326 |
// REVISIT: To be implemented!!!
|
|
1327 |
}
|
|
1328 |
|
33349
|
1329 |
|
|
1330 |
/**
|
|
1331 |
* @serialData Serialized fields. Convert Maps to Hashtables and Lists
|
|
1332 |
* to Vectors for backward compatibility.
|
|
1333 |
*/
|
|
1334 |
private void writeObject(ObjectOutputStream out) throws IOException {
|
|
1335 |
// Convert Maps to Hashtables, Lists to Vectors
|
|
1336 |
Vector<NodeIterator> it = (iterators == null)? null : new Vector<>(iterators);
|
|
1337 |
Vector<Range> r = (ranges == null)? null : new Vector<>(ranges);
|
|
1338 |
|
|
1339 |
Hashtable<NodeImpl, Vector<LEntry>> el = null;
|
|
1340 |
if (eventListeners != null) {
|
|
1341 |
el = new Hashtable<>();
|
|
1342 |
for (Map.Entry<NodeImpl, List<LEntry>> e : eventListeners.entrySet()) {
|
|
1343 |
el.put(e.getKey(), new Vector<>(e.getValue()));
|
|
1344 |
}
|
|
1345 |
}
|
|
1346 |
|
|
1347 |
// Write serialized fields
|
|
1348 |
ObjectOutputStream.PutField pf = out.putFields();
|
|
1349 |
pf.put("iterators", it);
|
|
1350 |
pf.put("ranges", r);
|
|
1351 |
pf.put("eventListeners", el);
|
|
1352 |
pf.put("mutationEvents", mutationEvents);
|
|
1353 |
out.writeFields();
|
|
1354 |
}
|
|
1355 |
|
|
1356 |
@SuppressWarnings("unchecked")
|
|
1357 |
private void readObject(ObjectInputStream in)
|
|
1358 |
throws IOException, ClassNotFoundException {
|
|
1359 |
// We have to read serialized fields first.
|
|
1360 |
ObjectInputStream.GetField gf = in.readFields();
|
|
1361 |
Vector<NodeIterator> it = (Vector<NodeIterator>)gf.get("iterators", null);
|
|
1362 |
Vector<Range> r = (Vector<Range>)gf.get("ranges", null);
|
|
1363 |
Hashtable<NodeImpl, Vector<LEntry>> el =
|
|
1364 |
(Hashtable<NodeImpl, Vector<LEntry>>)gf.get("eventListeners", null);
|
|
1365 |
|
|
1366 |
mutationEvents = gf.get("mutationEvents", false);
|
|
1367 |
|
|
1368 |
//convert Hashtables back to HashMaps and Vectors to Lists
|
|
1369 |
if (it != null) iterators = new ArrayList<>(it);
|
|
1370 |
if (r != null) ranges = new ArrayList<>(r);
|
|
1371 |
if (el != null) {
|
|
1372 |
eventListeners = new HashMap<>();
|
|
1373 |
for (Map.Entry<NodeImpl, Vector<LEntry>> e : el.entrySet()) {
|
|
1374 |
eventListeners.put(e.getKey(), new ArrayList<>(e.getValue()));
|
|
1375 |
}
|
|
1376 |
}
|
|
1377 |
}
|
12005
|
1378 |
} // class DocumentImpl
|