"Node", "EventTarget", and "DocumentEvent" implementation. * This provides most of the core DOM functionality; only more * specialized features are provided by subclasses. Those subclasses may * have some particular constraints they must implement, by overriding * methods defined here. Such constraints are noted here in the method * documentation.
* *Note that you can create events with type names prefixed with "USER-", * and pass them through this DOM. This lets you use the DOM event scheme * for application specific purposes, although you must use a predefined event * structure (such as MutationEvent) to pass data along with those events. * Test for existence of this feature with the "USER-Events" DOM feature * name.
* *Other kinds of events you can send include the "html" events, * like "load", "unload", "abort", "error", and "blur"; and the mutation * events. If this DOM has been compiled with mutation event support * enabled, it will send mutation events when you change parts of the * tree; otherwise you may create and send such events yourself, but * they won't be generated by the DOM itself.
* *Note that there is a namespace-aware name comparison method, * nameAndTypeEquals, which compares the names (and types) of * two nodes in conformance with the "Namespaces in XML" specification. * While mostly intended for use with elements and attributes, this should * also be helpful for ProcessingInstruction nodes and some others which * do not have namespace URIs. * * @author David Brownell * @author Chris Burdess */ public abstract class DomNode implements Node, NodeList, EventTarget, DocumentEvent, Cloneable, Comparable { // package private //final static String xmlNamespace = "http://www.w3.org/XML/1998/namespace"; //final static String xmlnsURI = "http://www.w3.org/2000/xmlns/"; // tunable // NKIDS_* affects arrays of children (which grow) // (currently) fixed size: // ANCESTORS_* is for event capture/bubbling, # ancestors // NOTIFICATIONS_* is for per-node event delivery, # events private static final int NKIDS_DELTA = 8; private static final int ANCESTORS_INIT = 20; private static final int NOTIFICATIONS_INIT = 10; // tunable: enable mutation events or not? Enabling it costs about // 10-15% in DOM construction time, last time it was measured. // package private !!! static final boolean reportMutations = true; // locking protocol changeable only within this class private static final Object lockNode = new Object(); // NON-FINAL class data // Optimize event dispatch by not allocating memory each time private static boolean dispatchDataLock; private static DomNode[] ancestors = new DomNode[ANCESTORS_INIT]; private static ListenerRecord[] notificationSet = new ListenerRecord[NOTIFICATIONS_INIT]; // Ditto for the (most common) event object itself! private static boolean eventDataLock; private static DomEvent.DomMutationEvent mutationEvent = new DomEvent.DomMutationEvent(null); // // PER-INSTANCE DATA // DomDocument owner; DomNode parent; // parent node; DomNode previous; // previous sibling node DomNode next; // next sibling node DomNode first; // first child node DomNode last; // last child node int index; // index of this node in its parent's children int depth; // depth of the node in the document int length; // number of children final short nodeType; // Bleech ... "package private" so a builder can populate entity refs. // writable during construction. DOM spec is nasty. boolean readonly; // event registrations private HashSet listeners; private int nListeners; // DOM Level 3 userData dictionary. private HashMap userData; private HashMap userDataHandlers; // // Some of the methods here are declared 'final' because // knowledge about their implementation is built into this // class -- for both integrity and performance. // /** * Reduces space utilization for this node. */ public void compact() { } /** * Constructs a node and associates it with its owner. Only * Document and DocumentType nodes may be created with no owner, * and DocumentType nodes get an owner as soon as they are * associated with a document. */ protected DomNode(short nodeType, DomDocument owner) { this.nodeType = nodeType; if (owner == null) { // DOM calls never go down this path if (nodeType != DOCUMENT_NODE && nodeType != DOCUMENT_TYPE_NODE) { throw new IllegalArgumentException ("no owner!"); } } this.owner = owner; this.listeners = new HashSet(); } /** * DOM L1 * Returns null; Element subclasses must override this method. */ public NamedNodeMap getAttributes() { return null; } /** * DOM L2> * Returns true iff this is an element node with attributes. */ public boolean hasAttributes() { return false; } /** * DOM L1 * Returns a list, possibly empty, of the children of this node. * In this implementation, to conserve memory, nodes are the same * as their list of children. This can have ramifications for * subclasses, which may need to provide their own getLength method * for reasons unrelated to the NodeList method of the same name. */ public NodeList getChildNodes() { return this; } /** * DOM L1 * Returns the first child of this node, or null if there are none. */ public Node getFirstChild() { return first; } /** * DOM L1 * Returns the last child of this node, or null if there are none. */ public Node getLastChild() { return last; } /** * DOM L1 * Returns true if this node has children. */ public boolean hasChildNodes() { return length != 0; } /** * Exposes the internal "readonly" flag. In DOM, children of * entities and entity references are readonly, as are the * objects associated with DocumentType objets. */ public final boolean isReadonly() { return readonly; } /** * Sets the internal "readonly" flag so this subtree can't be changed. * Subclasses need to override this method for any associated content * that's not a child node, such as an element's attributes or the * (few) declarations associated with a DocumentType. */ public void makeReadonly() { readonly = true; for (DomNode child = first; child != null; child = child.next) { child.makeReadonly(); } } /** * Used to adopt a node to a new document. */ void setOwner(DomDocument doc) { this.owner = doc; for (DomNode ctx = first; ctx != null; ctx = ctx.next) { ctx.setOwner(doc); } } // just checks the node for inclusion -- may be called many // times (docfrag) before anything is allowed to change private void checkMisc(DomNode child) { if (readonly && !owner.building) { throw new DomDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, null, this, 0); } for (DomNode ctx = this; ctx != null; ctx = ctx.parent) { if (child == ctx) { throw new DomDOMException(DOMException.HIERARCHY_REQUEST_ERR, "can't make ancestor into a child", this, 0); } } DomDocument owner = (nodeType == DOCUMENT_NODE) ? (DomDocument) this : this.owner; DomDocument childOwner = child.owner; short childNodeType = child.nodeType; if (childOwner != owner) { // new in DOM L2, this case -- patch it up later, in reparent() if (!(childNodeType == DOCUMENT_TYPE_NODE && childOwner == null)) { throw new DomDOMException(DOMException.WRONG_DOCUMENT_ERR, null, child, 0); } } // enforce various structural constraints switch (nodeType) { case DOCUMENT_NODE: switch (childNodeType) { case ELEMENT_NODE: case PROCESSING_INSTRUCTION_NODE: case COMMENT_NODE: case DOCUMENT_TYPE_NODE: return; } break; case ATTRIBUTE_NODE: switch (childNodeType) { case TEXT_NODE: case ENTITY_REFERENCE_NODE: return; } break; case DOCUMENT_FRAGMENT_NODE: case ENTITY_REFERENCE_NODE: case ELEMENT_NODE: case ENTITY_NODE: switch (childNodeType) { case ELEMENT_NODE: case TEXT_NODE: case COMMENT_NODE: case PROCESSING_INSTRUCTION_NODE: case CDATA_SECTION_NODE: case ENTITY_REFERENCE_NODE: return; } break; case DOCUMENT_TYPE_NODE: if (!owner.building) break; switch (childNodeType) { case COMMENT_NODE: case PROCESSING_INSTRUCTION_NODE: return; } break; } if (owner.checkingWellformedness) { throw new DomDOMException(DOMException.HIERARCHY_REQUEST_ERR, "can't append " + nodeTypeToString(childNodeType) + " to node of type " + nodeTypeToString(nodeType), this, 0); } } // Here's hoping a good optimizer will detect the case when the // next several methods are never called, and won't allocate // object code space of any kind. (Case: not reporting any // mutation events. We can also remove some static variables // listed above.) private void insertionEvent(DomEvent.DomMutationEvent event, DomNode target) { if (owner == null || owner.building) { return; } boolean doFree = false; if (event == null) { event = getMutationEvent(); } if (event != null) { doFree = true; } else { event = new DomEvent.DomMutationEvent(null); } event.initMutationEvent("DOMNodeInserted", true /* bubbles */, false /* nocancel */, this /* related */, null, null, null, (short) 0); target.dispatchEvent(event); // XXX should really visit every descendant of 'target' // and sent a DOMNodeInsertedIntoDocument event to it... // bleech, there's no way to keep that acceptably fast. if (doFree) { event.target = null; event.relatedNode = null; event.currentNode = null; eventDataLock = false; } // else we created work for the GC } private void removalEvent(DomEvent.DomMutationEvent event, DomNode target) { if (owner == null || owner.building) { return; } boolean doFree = false; if (event == null) { event = getMutationEvent(); } if (event != null) { doFree = true; } else { event = new DomEvent.DomMutationEvent(null); } event.initMutationEvent("DOMNodeRemoved", true /* bubbles */, false /* nocancel */, this /* related */, null, null, null, (short) 0); target.dispatchEvent(event); // XXX should really visit every descendant of 'target' // and sent a DOMNodeRemovedFromDocument event to it... // bleech, there's no way to keep that acceptably fast. event.target = null; event.relatedNode = null; event.currentNode = null; if (doFree) { eventDataLock = false; } // else we created more work for the GC } // // Avoid creating lots of memory management work, by using a simple // allocation strategy for the mutation event objects that get used // at least once per tree modification. We can't use stack allocation, // so we do the next simplest thing -- more or less, static allocation. // Concurrent notifications should be rare, anyway. // // Returns the preallocated object, which needs to be carefully freed, // or null to indicate the caller needs to allocate their own. // static private DomEvent.DomMutationEvent getMutationEvent() { synchronized (lockNode) { if (eventDataLock) { return null; } eventDataLock = true; return mutationEvent; } } // NOTE: this is manually inlined in the insertion // and removal event methods above; change in sync. static private void freeMutationEvent() { // clear fields to enable GC mutationEvent.clear(); eventDataLock = false; } void setDepth(int depth) { this.depth = depth; for (DomNode ctx = first; ctx != null; ctx = ctx.next) { ctx.setDepth(depth + 1); } } /** * DOM L1 * Appends the specified node to this node's list of children. * Document subclasses must override this to enforce the restrictions * that there be only one element and document type child. * *
Causes a DOMNodeInserted mutation event to be reported. * Will first cause a DOMNodeRemoved event to be reported if the * parameter already has a parent. If the new child is a document * fragment node, both events will be reported for each child of * the fragment; the order in which children are removed and * inserted is implementation-specific. * *
If this DOM has been compiled without mutation event support, * these events will not be reported. */ public Node appendChild(Node newChild) { try { DomNode child = (DomNode) newChild; if (child.nodeType == DOCUMENT_FRAGMENT_NODE) { // Append all nodes in the fragment to this node for (DomNode ctx = child.first; ctx != null; ctx = ctx.next) { checkMisc(ctx); } for (DomNode ctx = child.first; ctx != null; ) { DomNode ctxNext = ctx.next; appendChild(ctx); ctx = ctxNext; } } else { checkMisc(child); if (child.parent != null) { child.parent.removeChild(child); } child.parent = this; child.index = length++; child.setDepth(depth + 1); child.next = null; if (last == null) { first = child; child.previous = null; } else { last.next = child; child.previous = last; } last = child; if (reportMutations) { insertionEvent(null, child); } } return child; } catch (ClassCastException e) { throw new DomDOMException(DOMException.WRONG_DOCUMENT_ERR, null, newChild, 0); } } /** * DOM L1 * Inserts the specified node in this node's list of children. * Document subclasses must override this to enforce the restrictions * that there be only one element and document type child. * *
Causes a DOMNodeInserted mutation event to be reported. Will * first cause a DOMNodeRemoved event to be reported if the newChild * parameter already has a parent. If the new child is a document * fragment node, both events will be reported for each child of * the fragment; the order in which children are removed and inserted * is implementation-specific. * *
If this DOM has been compiled without mutation event support, * these events will not be reported. */ public Node insertBefore(Node newChild, Node refChild) { if (refChild == null) { return appendChild(newChild); } try { DomNode child = (DomNode) newChild; DomNode ref = (DomNode) refChild; if (child.nodeType == DOCUMENT_FRAGMENT_NODE) { // Append all nodes in the fragment to this node for (DomNode ctx = child.first; ctx != null; ctx = ctx.next) { checkMisc(ctx); } for (DomNode ctx = child.first; ctx != null; ) { DomNode ctxNext = ctx.next; insertBefore(ctx, ref); ctx = ctxNext; } } else { checkMisc(child); if (ref == null || ref.parent != this) { throw new DomDOMException(DOMException.NOT_FOUND_ERR, null, ref, 0); } if (ref == child) { throw new DomDOMException(DOMException.HIERARCHY_REQUEST_ERR, "can't insert node before itself", ref, 0); } if (child.parent != null) { child.parent.removeChild(child); } child.parent = this; int i = ref.index; child.setDepth(depth + 1); child.next = ref; if (ref.previous != null) { ref.previous.next = child; } child.previous = ref.previous; ref.previous = child; if (first == ref) { first = child; } // index renumbering for (DomNode ctx = child; ctx != null; ctx = ctx.next) { ctx.index = i++; } if (reportMutations) { insertionEvent(null, child); } length++; } return child; } catch (ClassCastException e) { throw new DomDOMException(DOMException.WRONG_DOCUMENT_ERR, null, newChild, 0); } } /** * DOM L1 * Replaces the specified node in this node's list of children. * Document subclasses must override this to test the restrictions * that there be only one element and document type child. * *
Causes DOMNodeRemoved and DOMNodeInserted mutation event to be * reported. Will cause another DOMNodeRemoved event to be reported if * the newChild parameter already has a parent. These events may be * delivered in any order, except that the event reporting removal * from such an existing parent will always be delivered before the * event reporting its re-insertion as a child of some other node. * The order in which children are removed and inserted is implementation * specific. * *
If your application needs to depend on the in which those removal * and insertion events are delivered, don't use this API. Instead, * invoke the removeChild and insertBefore methods directly, to guarantee * a specific delivery order. Similarly, don't use document fragments, * Otherwise your application code may not work on a DOM which implements * this method differently. * *
If this DOM has been compiled without mutation event support, * these events will not be reported. */ public Node replaceChild(Node newChild, Node refChild) { try { DomNode child = (DomNode) newChild; DomNode ref = (DomNode) refChild; DomEvent.DomMutationEvent event = getMutationEvent(); boolean doFree = (event != null); if (child.nodeType == DOCUMENT_FRAGMENT_NODE) { // Append all nodes in the fragment to this node for (DomNode ctx = child.first; ctx != null; ctx = ctx.next) { checkMisc(ctx); } if (ref == null || ref.parent != this) { throw new DomDOMException(DOMException.NOT_FOUND_ERR, null, ref, 0); } if (reportMutations) { removalEvent(event, ref); } length--; length += child.length; if (child.length == 0) { // Removal if (ref.previous != null) { ref.previous.next = ref.next; } if (ref.next != null) { ref.next.previous = ref.previous; } if (first == ref) { first = ref.next; } if (last == ref) { last = ref.previous; } } else { int i = ref.index; for (DomNode ctx = child.first; ctx != null; ctx = ctx.next) { // Insertion ctx.parent = this; ctx.index = i++; ctx.setDepth(ref.depth); if (ctx == child.first) { ctx.previous = ref.previous; } if (ctx == child.last) { ctx.next = ref.next; } } if (first == ref) { first = child.first; } if (last == ref) { last = child.last; } } } else { checkMisc(child); if (ref == null || ref.parent != this) { throw new DomDOMException(DOMException.NOT_FOUND_ERR, null, ref, 0); } if (reportMutations) { removalEvent(event, ref); } if (child.parent != null) { child.parent.removeChild(child); } child.parent = this; child.index = ref.index; child.setDepth(ref.depth); if (ref.previous != null) { ref.previous.next = child; } child.previous = ref.previous; if (ref.next != null) { ref.next.previous = child; } child.next = ref.next; if (first == ref) { first = child; } if (last == ref) { last = child; } if (reportMutations) { insertionEvent(event, child); } if (doFree) { freeMutationEvent(); } } ref.parent = null; ref.index = 0; ref.setDepth(0); ref.previous = null; ref.next = null; return ref; } catch (ClassCastException e) { throw new DomDOMException(DOMException.WRONG_DOCUMENT_ERR, null, newChild, 0); } } /** * DOM L1 * Removes the specified child from this node's list of children, * or else reports an exception. * *
Causes a DOMNodeRemoved mutation event to be reported. * *
If this DOM has been compiled without mutation event support, * these events will not be reported. */ public Node removeChild(Node refChild) { try { DomNode ref = (DomNode) refChild; if (ref == null || ref.parent != this) { throw new DomDOMException(DOMException.NOT_FOUND_ERR, null, ref, 0); } if (readonly && !owner.building) { throw new DomDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, null, this, 0); } for (DomNode child = first; child != null; child = child.next) { if (child == ref) { if (reportMutations) { removalEvent(null, child); } length--; if (ref.previous != null) { ref.previous.next = ref.next; } if (ref.next != null) { ref.next.previous = ref.previous; } if (first == ref) { first = ref.next; } if (last == ref) { last = ref.previous; } // renumber indices int i = 0; for (DomNode ctx = first; ctx != null; ctx = ctx.next) { ctx.index = i++; } ref.parent = null; ref.setDepth(0); ref.index = 0; ref.previous = null; ref.next = null; return ref; } } throw new DomDOMException(DOMException.NOT_FOUND_ERR, "that's no child of mine", refChild, 0); } catch (ClassCastException e) { throw new DomDOMException(DOMException.WRONG_DOCUMENT_ERR, null, refChild, 0); } } /** * DOM L1 (NodeList) * Returns the item with the specified index in this NodeList, * else null. */ public Node item(int index) { DomNode child = first; int count = 0; while (child != null && count < index) { child = child.next; count++; } return child; } /** * DOM L1 (NodeList) * Returns the number of elements in this NodeList. * (Note that many interfaces have a "Length" property, not just * NodeList, and if a node subtype must implement one of those, * it will also need to override getChildNodes.) */ public int getLength() { return length; } /** * Minimize extra space consumed by this node to hold children and event * listeners. */ public void trimToSize() { } /** * DOM L1 * Returns the previous sibling, if one is known. */ public Node getNextSibling() { return next; } /** * DOM L1 * Returns the previous sibling, if one is known. */ public Node getPreviousSibling() { return previous; } /** * DOM L1 * Returns the parent node, if one is known. */ public Node getParentNode() { return parent; } /** * DOM L2 * Consults the DOM implementation to determine if the requested * feature is supported. DocumentType subclasses must override * this method, and associate themselves directly with the * DOMImplementation node used. (This method relies on being able * to access the DOMImplementation from the owner document, but * DocumentType nodes can be created without an owner.) */ public boolean isSupported(String feature, String version) { Document doc = owner; DOMImplementation impl = null; if (doc == null && nodeType == DOCUMENT_NODE) { doc = (Document) this; } if (doc == null) { // possible for DocumentType throw new IllegalStateException ("unbound ownerDocument"); } impl = doc.getImplementation(); return impl.hasFeature(feature, version); } /** * DOM L1 (modified in L2) * Returns the owner document. This is only null for Document nodes, * and (new in L2) for DocumentType nodes which have not yet been * associated with the rest of their document. */ final public Document getOwnerDocument() { return owner; } /** * DOM L1 * Does nothing; this must be overridden (along with the * getNodeValue method) for nodes with a non-null defined value. */ public void setNodeValue(String value) { } /** * DOM L1 * Returns null; this must be overridden for nodes types with * a defined value, along with the setNodeValue method. */ public String getNodeValue() { return null; } /** This forces GCJ compatibility. * Without this method GCJ is unable to compile to byte code. */ public final short getNodeType() { return nodeType; } /** This forces GCJ compatibility. * Without this method GCJ seems unable to natively compile GNUJAXP. */ public abstract String getNodeName(); /** * DOM L2 * Does nothing; this must be overridden (along with the * getPrefix method) for element and attribute nodes. */ public void setPrefix(String prefix) { } /** * DOM L2 * Returns null; this must be overridden for element and * attribute nodes. */ public String getPrefix() { return null; } /** * DOM L2 * Returns null; this must be overridden for element and * attribute nodes. */ public String getNamespaceURI() { return null; } /** * DOM L2 * Returns the node name; this must be overridden for element and * attribute nodes. */ public String getLocalName() { return null; } /** * DOM L1 * Returns a clone of this node which optionally includes cloned * versions of child nodes. Clones are always mutable, except for * entity reference nodes. */ public Node cloneNode(boolean deep) { if (deep) { return cloneNodeDeepInternal(true, null); } DomNode node = (DomNode) clone(); if (nodeType == ENTITY_REFERENCE_NODE) { node.makeReadonly(); } notifyUserDataHandlers(UserDataHandler.NODE_CLONED, this, node); return node; } /** * Returns a deep clone of this node. */ private DomNode cloneNodeDeepInternal(boolean root, DomDocument doc) { DomNode node = (DomNode) clone(); boolean building = false; // Never used unless root is true if (root) { doc = (nodeType == DOCUMENT_NODE) ? (DomDocument) node : node.owner; building = doc.building; doc.building = true; // Permit certain structural rules } node.owner = doc; for (DomNode ctx = first; ctx != null; ctx = ctx.next) { DomNode newChild = ctx.cloneNodeDeepInternal(false, doc); node.appendChild(newChild); } if (nodeType == ENTITY_REFERENCE_NODE) { node.makeReadonly(); } if (root) { doc.building = building; } notifyUserDataHandlers(UserDataHandler.NODE_CLONED, this, node); return node; } void notifyUserDataHandlers(short op, Node src, Node dst) { if (userDataHandlers != null) { for (Iterator i = userDataHandlers.entrySet().iterator(); i.hasNext(); ) { Map.Entry entry = (Map.Entry) i.next(); String key = (String) entry.getKey(); UserDataHandler handler = (UserDataHandler) entry.getValue(); Object data = userData.get(key); handler.handle(op, key, data, src, dst); } } } /** * Clones this node; roughly equivalent to cloneNode(false). * Element subclasses must provide a new implementation which * invokes this method to handle the basics, and then arranges * to clone any element attributes directly. Attribute subclasses * must make similar arrangements, ensuring that existing ties to * elements are broken by cloning. */ public Object clone() { try { DomNode node = (DomNode) super.clone(); node.parent = null; node.depth = 0; node.index = 0; node.length = 0; node.first = null; node.last = null; node.previous = null; node.next = null; node.readonly = false; node.listeners = new HashSet(); node.nListeners = 0; return node; } catch (CloneNotSupportedException x) { throw new Error("clone didn't work"); } } // the elements-by-tagname stuff is needed for both // elements and documents ... this is in lieu of a // common base class between Node and NodeNS. /** * DOM L1 * Creates a NodeList giving array-style access to elements with * the specified name. Access is fastest if indices change by * small values, and the DOM is not modified. */ public NodeList getElementsByTagName(String tag) { return new ShadowList(null, tag); } /** * DOM L2 * Creates a NodeList giving array-style access to elements with * the specified namespace and local name. Access is fastest if * indices change by small values, and the DOM is not modified. */ public NodeList getElementsByTagNameNS(String namespace, String local) { return new ShadowList(namespace, local); } // // This shadow class is GC-able even when the live list it shadows // can't be, because of event registration hookups. Its finalizer // makes that live list become GC-able. // final class ShadowList implements NodeList { private LiveNodeList liveList; ShadowList(String ns, String local) { liveList = new LiveNodeList(ns, local); } public void finalize() { liveList.detach(); liveList = null; } public Node item(int index) { return liveList.item(index); } public int getLength() { return liveList.getLength(); } } final class LiveNodeList implements NodeList, EventListener, NodeFilter { private final boolean matchAnyURI; private final boolean matchAnyName; private final String elementURI; private final String elementName; private DomIterator current; private int lastIndex; LiveNodeList(String uri, String name) { elementURI = uri; elementName = name; matchAnyURI = "*".equals(uri); matchAnyName = "*".equals(name); DomNode.this.addEventListener("DOMNodeInserted", this, true); DomNode.this.addEventListener("DOMNodeRemoved", this, true); } void detach() { if (current != null) current.detach(); current = null; DomNode.this.removeEventListener("DOMNodeInserted", this, true); DomNode.this.removeEventListener("DOMNodeRemoved", this, true); } public short acceptNode(Node element) { if (element == DomNode.this) { return FILTER_SKIP; } // use namespace-aware matching ... if (elementURI != null) { if (!(matchAnyURI || elementURI.equals(element.getNamespaceURI()))) { return FILTER_SKIP; } if (!(matchAnyName || elementName.equals(element.getLocalName()))) { return FILTER_SKIP; } // ... or qName-based kind. } else { if (!(matchAnyName || elementName.equals(element.getNodeName()))) { return FILTER_SKIP; } } return FILTER_ACCEPT; } private DomIterator createIterator() { return new DomIterator(DomNode.this, NodeFilter.SHOW_ELEMENT, this, /* filter */ true /* expand entity refs */ ); } public void handleEvent(Event e) { MutationEvent mutation = (MutationEvent) e; Node related = mutation.getRelatedNode(); // XXX if it's got children ... check all kids too, they // will invalidate our saved index if (related.getNodeType() != Node.ELEMENT_NODE || related.getNodeName() != elementName || related.getNamespaceURI() != elementURI) { return; } if (current != null) current.detach(); current = null; } public Node item(int index) { if (current == null) { current = createIterator(); lastIndex = -1; } // last node or before? go backwards if (index <= lastIndex) { while (index != lastIndex) { current.previousNode (); lastIndex--; } Node ret = current.previousNode (); current.detach(); current = null; return ret; } // somewhere after last node while (++lastIndex != index) current.nextNode (); Node ret = current.nextNode (); current.detach(); current = null; return ret; } public int getLength() { int retval = 0; NodeIterator iter = createIterator(); while (iter.nextNode() != null) { retval++; } iter.detach(); return retval; } } // // EventTarget support // static final class ListenerRecord { String type; EventListener listener; boolean useCapture; // XXX use JDK 1.2 java.lang.ref.WeakReference to listener, // and we can both get rid of "shadow" classes and remove // the need for applications to apply similar trix ... but // JDK 1.2 support isn't generally available yet ListenerRecord(String type, EventListener listener, boolean useCapture) { this.type = type.intern(); this.listener = listener; this.useCapture = useCapture; } public boolean equals(Object o) { ListenerRecord rec = (ListenerRecord)o; return listener == rec.listener && useCapture == rec.useCapture && type == rec.type; } public int hashCode() { return listener.hashCode() ^ type.hashCode(); } } /** * DOM L2 (Events) * Returns an instance of the specified type of event object. * Understands about DOM Mutation, HTML, and UI events. * *
If the name of the event type begins with "USER-", then an object * implementing the "Event" class will be returned; this provides a * limited facility for application-defined events to use the DOM event * infrastructure. Alternatively, use one of the standard DOM event * classes and initialize it using use such a "USER-" event type name; * or defin, instantiate, and initialize an application-specific subclass * of DomEvent and pass that to dispatchEvent(). * * @param eventType Identifies the particular DOM feature module * defining the type of event, such as "MutationEvents". * The event "name" is a different kind of "type". */ public Event createEvent(String eventType) { eventType = eventType.toLowerCase(); if ("mutationevents".equals(eventType)) { return new DomEvent.DomMutationEvent(null); } if ("htmlevents".equals(eventType) || "events".equals(eventType) || "user-events".equals(eventType)) { return new DomEvent(null); } if ("uievents".equals(eventType)) { return new DomEvent.DomUIEvent(null); } // mouse events throw new DomDOMException(DOMException.NOT_SUPPORTED_ERR, eventType, null, 0); } /** * DOM L2 (Events) * Registers an event listener's interest in a class of events. */ public final void addEventListener(String type, EventListener listener, boolean useCapture) { // prune duplicates ListenerRecord record; record = new ListenerRecord(type, listener, useCapture); listeners.add(record); nListeners = listeners.size(); } // XXX this exception should be discarded from DOM // this class can be instantiated, unlike the one in the spec static final class DomEventException extends EventException { DomEventException() { super(UNSPECIFIED_EVENT_TYPE_ERR, "unspecified event type"); } } /** * DOM L2 (Events) * Delivers an event to all relevant listeners, returning true if the * caller should perform their default action. Note that the event * must have been provided by the createEvent() method on this * class, else it can't be dispatched. * * @see #createEvent * * @exception NullPointerException When a null event is passed. * @exception ClassCastException When the event wasn't provided by * the createEvent method, or otherwise isn't a DomEvent. * @exception EventException If the event type wasn't specified */ public final boolean dispatchEvent(Event event) throws EventException { DomEvent e = (DomEvent) event; DomNode[] ancestors = null; int ancestorMax = 0; boolean haveDispatchDataLock = false; if (e.type == null) { throw new DomEventException(); } e.doDefault = true; e.target = this; // // Typical case: one nonrecursive dispatchEvent call at a time // for this class. If that's our case, we can avoid allocating // garbage, which is overall a big win. Even with advanced GCs // that deal well with short-lived garbage, and wayfast allocators, // it still helps. // // Remember -- EVERY mutation goes though here at least once. // // When populating a DOM tree, trying to send mutation events is // the primary cost; this dominates the critical path. // try { DomNode current; int index; boolean haveAncestorRegistrations = false; ListenerRecord[] notificationSet; int ancestorLen; synchronized (lockNode) { if (!dispatchDataLock) { haveDispatchDataLock = dispatchDataLock = true; notificationSet = DomNode.notificationSet; ancestors = DomNode.ancestors; } else { notificationSet = new ListenerRecord[NOTIFICATIONS_INIT]; ancestors = new DomNode[ANCESTORS_INIT]; } ancestorLen = ancestors.length; } // Climb to the top of this subtree and handle capture, letting // each node (from the top down) capture until one stops it or // until we get to this one. current = (parent == null) ? this : parent; if (current.depth >= ANCESTORS_INIT) { DomNode[] newants = new DomNode[current.depth + 1]; System.arraycopy(ancestors, 0, newants, 0, ancestors.length); ancestors = newants; ancestorLen = ancestors.length; } for (index = 0; index < ancestorLen; index++) { if (current == null || current.depth == 0) break; if (current.nListeners != 0) { haveAncestorRegistrations = true; } ancestors [index] = current; current = current.parent; } if (current.depth > 0) { throw new RuntimeException("dispatchEvent capture stack size"); } ancestorMax = index; e.stop = false; if (haveAncestorRegistrations) { e.eventPhase = Event.CAPTURING_PHASE; while (!e.stop && index-- > 0) { current = ancestors [index]; if (current.nListeners != 0) { notifyNode(e, current, true, notificationSet); } } } // Always deliver events to the target node (this) // unless stopPropagation was called. If we saw // no registrations yet (typical!), we never will. if (!e.stop && nListeners != 0) { e.eventPhase = Event.AT_TARGET; notifyNode (e, this, false, notificationSet); } else if (!haveAncestorRegistrations) { e.stop = true; } // If the event bubbles and propagation wasn't halted, // walk back up the ancestor list. Stop bubbling when // any bubbled event handler stops it. if (!e.stop && e.bubbles) { e.eventPhase = Event.BUBBLING_PHASE; for (index = 0; !e.stop && index < ancestorMax && (current = ancestors[index]) != null; index++) { if (current.nListeners != 0) { notifyNode(e, current, false, notificationSet); } } } e.eventPhase = 0; // Caller chooses whether to perform the default // action based on return from this method. return e.doDefault; } finally { if (haveDispatchDataLock) { // synchronize to force write ordering synchronized (lockNode) { // null out refs to ensure they'll be GC'd for (int i = 0; i < ancestorMax; i++) { ancestors [i] = null; } // notificationSet handled by notifyNode dispatchDataLock = false; } } } } private void notifyNode(DomEvent e, DomNode current, boolean capture, ListenerRecord[] notificationSet) { int count = 0; Iterator iter; iter = current.listeners.iterator(); // do any of this set of listeners get notified? while (iter.hasNext()) { ListenerRecord rec = (ListenerRecord)iter.next(); if (rec.useCapture != capture) { continue; } if (!e.type.equals (rec.type)) { continue; } if (count >= notificationSet.length) { // very simple growth algorithm int len = Math.max(notificationSet.length, 1); ListenerRecord[] tmp = new ListenerRecord[len * 2]; System.arraycopy(notificationSet, 0, tmp, 0, notificationSet.length); notificationSet = tmp; } notificationSet[count++] = rec; } iter = null; // Notify just those listeners e.currentNode = current; for (int i = 0; i < count; i++) { try { iter = current.listeners.iterator(); // Late in the DOM CR process (3rd or 4th CR?) the // removeEventListener spec became asymmetric with respect // to addEventListener ... effect is now immediate. while (iter.hasNext()) { ListenerRecord rec = (ListenerRecord)iter.next(); if (rec.equals(notificationSet[i])) { notificationSet[i].listener.handleEvent(e); break; } } iter = null; } catch (Exception x) { // ignore all exceptions } notificationSet[i] = null; // free for GC } } /** * DOM L2 (Events) * Unregisters an event listener. */ public final void removeEventListener(String type, EventListener listener, boolean useCapture) { listeners.remove(new ListenerRecord(type, listener, useCapture)); nListeners = listeners.size(); // no exceptions reported } /** * DOM L1 (relocated in DOM L2) * In this node and all contained nodes (including attributes if * relevant) merge adjacent text nodes. This is done while ignoring * text which happens to use CDATA delimiters). */ public final void normalize() { // Suspend readonly status boolean saved = readonly; readonly = false; for (DomNode ctx = first; ctx != null; ctx = ctx.next) { boolean saved2 = ctx.readonly; ctx.readonly = false; switch (ctx.nodeType) { case TEXT_NODE: case CDATA_SECTION_NODE: while (ctx.next != null && (ctx.next.nodeType == TEXT_NODE || ctx.next.nodeType == CDATA_SECTION_NODE)) { Text text = (Text) ctx; text.appendData(ctx.next.getNodeValue()); removeChild(ctx.next); } break; case ELEMENT_NODE: NamedNodeMap attrs = ctx.getAttributes(); int len = attrs.getLength(); for (int i = 0; i < len; i++) { DomNode attr = (DomNode) attrs.item(i); boolean saved3 = attr.readonly; attr.readonly = false; attr.normalize(); attr.readonly = saved3; } // Fall through case DOCUMENT_NODE: case DOCUMENT_FRAGMENT_NODE: case ATTRIBUTE_NODE: case ENTITY_REFERENCE_NODE: ctx.normalize(); break; } ctx.readonly = saved2; } readonly = saved; } /** * Returns true iff node types match, and either (a) both nodes have no * namespace and their getNodeName() values are the same, or (b) both * nodes have the same getNamespaceURI() and same getLocalName() values. * *
Note that notion of a "Per-Element-Type" attribute name scope, as * found in a non-normative appendix of the XML Namespaces specification, * is not supported here. Your application must implement that notion, * typically by not bothering to check nameAndTypeEquals for attributes * without namespace URIs unless you already know their elements are * nameAndTypeEquals. */ public boolean nameAndTypeEquals(Node other) { if (other == this) { return true; } // node types must match if (nodeType != other.getNodeType()) { return false; } // if both have namespaces, do a "full" comparision // this is a "global" partition String ns1 = this.getNamespaceURI(); String ns2 = other.getNamespaceURI(); if (ns1 != null && ns2 != null) { return ns1.equals(ns2) && equal(getLocalName(), other.getLocalName()); } // if neither has a namespace, this is a "no-namespace" name. if (ns1 == null && ns2 == null) { if (!getNodeName().equals(other.getNodeName())) { return false; } // can test the non-normative "per-element-type" scope here. // if this is an attribute node and both nodes have been bound // to elements (!!), then return the nameAndTypeEquals() // comparison of those elements. return true; } // otherwise they're unequal: one scoped, one not. return false; } // DOM Level 3 methods public String getBaseURI() { return (parent != null) ? parent.getBaseURI() : null; } public short compareDocumentPosition(Node other) throws DOMException { return (short) compareTo(other); } /** * DOM nodes have a natural ordering: document order. */ public final int compareTo(Object other) { if (other instanceof DomNode) { DomNode n1 = this; DomNode n2 = (DomNode) other; if (n1.owner != n2.owner) { return 0; } int d1 = n1.depth, d2 = n2.depth; int delta = d1 - d2; while (d1 > d2) { n1 = n1.parent; d1--; } while (d2 > d1) { n2 = n2.parent; d2--; } int c = compareTo2(n1, n2); return (c != 0) ? c : delta; } return 0; } /** * Compare two nodes at the same depth. */ final int compareTo2(DomNode n1, DomNode n2) { if (n1 == n2 || n1.depth == 0 || n2.depth == 0) { return 0; } int c = compareTo2(n1.parent, n2.parent); return (c != 0) ? c : n1.index - n2.index; } public final String getTextContent() throws DOMException { return getTextContent(true); } final String getTextContent(boolean topLevel) throws DOMException { switch (nodeType) { case ELEMENT_NODE: case ENTITY_NODE: case ENTITY_REFERENCE_NODE: case DOCUMENT_FRAGMENT_NODE: CPStringBuilder buffer = new CPStringBuilder(); for (DomNode ctx = first; ctx != null; ctx = ctx.next) { String textContent = ctx.getTextContent(false); if (textContent != null) { buffer.append(textContent); } } return buffer.toString(); case TEXT_NODE: case CDATA_SECTION_NODE: if (((Text) this).isElementContentWhitespace()) { return ""; } return getNodeValue(); case ATTRIBUTE_NODE: return getNodeValue(); case COMMENT_NODE: case PROCESSING_INSTRUCTION_NODE: return topLevel ? getNodeValue() : ""; default: return null; } } public void setTextContent(String textContent) throws DOMException { switch (nodeType) { case ELEMENT_NODE: case ATTRIBUTE_NODE: case ENTITY_NODE: case ENTITY_REFERENCE_NODE: case DOCUMENT_FRAGMENT_NODE: for (DomNode ctx = first; ctx != null; ) { DomNode n = ctx.next; removeChild(ctx); ctx = n; } if (textContent != null) { Text text = owner.createTextNode(textContent); appendChild(text); } break; case TEXT_NODE: case CDATA_SECTION_NODE: case COMMENT_NODE: case PROCESSING_INSTRUCTION_NODE: setNodeValue(textContent); break; } } public boolean isSameNode(Node other) { return this == other; } public String lookupPrefix(String namespaceURI) { return (parent == null || parent == owner) ? null : parent.lookupPrefix(namespaceURI); } public boolean isDefaultNamespace(String namespaceURI) { return (parent == null || parent == owner) ? false : parent.isDefaultNamespace(namespaceURI); } public String lookupNamespaceURI(String prefix) { return (parent == null || parent == owner) ? null : parent.lookupNamespaceURI(prefix); } public boolean isEqualNode(Node arg) { if (this == arg) return true; if (arg == null) return false; if (nodeType != arg.getNodeType()) return false; switch (nodeType) { case ELEMENT_NODE: case ATTRIBUTE_NODE: if (!equal(getLocalName(), arg.getLocalName()) || !equal(getNamespaceURI(), arg.getNamespaceURI())) return false; break; case PROCESSING_INSTRUCTION_NODE: if (!equal(getNodeName(), arg.getNodeName()) || !equal(getNodeValue(), arg.getNodeValue())) return false; break; case COMMENT_NODE: case TEXT_NODE: case CDATA_SECTION_NODE: if (!equal(getNodeValue(), arg.getNodeValue())) return false; break; } // Children Node argCtx = arg.getFirstChild(); getFirstChild(); // because of DomAttr lazy children DomNode ctx = first; for (; ctx != null && argCtx != null; ctx = ctx.next) { if (nodeType == DOCUMENT_NODE) { // Ignore whitespace outside document element while (ctx != null && ctx.nodeType == TEXT_NODE) ctx = ctx.next; while (argCtx != null && ctx.getNodeType() == TEXT_NODE) argCtx = argCtx.getNextSibling(); if (ctx == null && argCtx != null) return false; else if (argCtx == null && ctx != null) return false; } if (!ctx.isEqualNode(argCtx)) return false; argCtx = argCtx.getNextSibling(); } if (ctx != null || argCtx != null) return false; // TODO DocumentType return true; } boolean equal(String arg1, String arg2) { return ((arg1 == null && arg2 == null) || (arg1 != null && arg1.equals(arg2))); } public Object getFeature(String feature, String version) { DOMImplementation impl = (nodeType == DOCUMENT_NODE) ? ((Document) this).getImplementation() : owner.getImplementation(); if (impl.hasFeature(feature, version)) { return this; } return null; } public Object setUserData(String key, Object data, UserDataHandler handler) { if (userData == null) { userData = new HashMap(); } if (handler != null) { if (userDataHandlers == null) { userDataHandlers = new HashMap(); } userDataHandlers.put(key, handler); } return userData.put(key, data); } public Object getUserData(String key) { if (userData == null) { return null; } return userData.get(key); } public String toString() { String nodeName = getNodeName(); String nodeValue = getNodeValue(); CPStringBuilder buf = new CPStringBuilder(getClass().getName()); buf.append('['); if (nodeName != null) { buf.append(nodeName); } if (nodeValue != null) { if (nodeName != null) { buf.append('='); } buf.append('\''); buf.append(encode(nodeValue)); buf.append('\''); } buf.append(']'); return buf.toString(); } String encode(String value) { CPStringBuilder buf = null; int len = value.length(); for (int i = 0; i < len; i++) { char c = value.charAt(i); if (c == '\n') { if (buf == null) { buf = new CPStringBuilder(value.substring(0, i)); } buf.append("\\n"); } else if (c == '\r') { if (buf == null) { buf = new CPStringBuilder(value.substring(0, i)); } buf.append("\\r"); } else if (buf != null) { buf.append(c); } } return (buf != null) ? buf.toString() : value; } String nodeTypeToString(short nodeType) { switch (nodeType) { case ELEMENT_NODE: return "ELEMENT_NODE"; case ATTRIBUTE_NODE: return "ATTRIBUTE_NODE"; case TEXT_NODE: return "TEXT_NODE"; case CDATA_SECTION_NODE: return "CDATA_SECTION_NODE"; case DOCUMENT_NODE: return "DOCUMENT_NODE"; case DOCUMENT_TYPE_NODE: return "DOCUMENT_TYPE_NODE"; case COMMENT_NODE: return "COMMENT_NODE"; case PROCESSING_INSTRUCTION_NODE: return "PROCESSING_INSTRUCTION_NODE"; case DOCUMENT_FRAGMENT_NODE: return "DOCUMENT_FRAGMENT_NODE"; case ENTITY_NODE: return "ENTITY_NODE"; case ENTITY_REFERENCE_NODE: return "ENTITY_REFERENCE_NODE"; case NOTATION_NODE: return "NOTATION_NODE"; default: return "UNKNOWN"; } } public void list(java.io.PrintStream out, int indent) { for (int i = 0; i < indent; i++) out.print(" "); out.println(toString()); for (DomNode ctx = first; ctx != null; ctx = ctx.next) ctx.list(out, indent + 1); } }