Applications may define application specific event subclasses, but * should otherwise use the DocumentTraversal interface to acquire * event objects. * * @author David Brownell */ public class DomEvent implements Event { String type; // init EventTarget target; EventTarget currentNode; short eventPhase; boolean bubbles; // init boolean cancelable; // init long timeStamp; // ? /** Returns the event's type (name) as initialized */ public final String getType() { return type; } /** * Returns event's target; delivery of an event is initiated * by a target.dispatchEvent(event) invocation. */ public final EventTarget getTarget() { return target; } /** * Returns the target to which events are currently being * delivered. When capturing or bubbling, this will not * be what getTarget returns. */ public final EventTarget getCurrentTarget() { return currentNode; } /** * Returns CAPTURING_PHASE, AT_TARGET, or BUBBLING; * only meaningful within EventListener.handleEvent */ public final short getEventPhase() { return eventPhase; } /** * Returns true if the news of the event bubbles to tree tops * (as specified during initialization). */ public final boolean getBubbles() { return bubbles; } /** * Returns true if the default handling may be canceled * (as specified during initialization). */ public final boolean getCancelable() { return cancelable; } /** * Returns the event's timestamp. */ public final long getTimeStamp() { return timeStamp; } boolean stop; boolean doDefault; /** * Requests the event no longer be captured or bubbled; only * listeners on the event target will see the event, if they * haven't yet been notified. * *
Avoid using this except for application-specific * events, for which you the protocol explicitly "blesses" the use * of this with some event types. Otherwise, you are likely to break * algorithms which depend on event notification either directly or * through bubbling or capturing.
* *Note that this method is not final, specifically to enable * enforcing of policies about events always propagating.
*/ public void stopPropagation() { stop = true; } /** * Requests that whoever dispatched the event not perform their * default processing when event delivery completes. Initializes * event timestamp. */ public final void preventDefault() { doDefault = false; } /** Initializes basic event state. */ public void initEvent(String typeArg, boolean canBubbleArg, boolean cancelableArg) { eventPhase = 0; type = typeArg; bubbles = canBubbleArg; cancelable = cancelableArg; timeStamp = System.currentTimeMillis(); } /** Constructs, but does not initialize, an event. */ public DomEvent(String type) { this.type = type; } /** * Returns a basic printable description of the event's type, * state, and delivery conditions */ public String toString() { CPStringBuilder buf = new CPStringBuilder("[Event "); buf.append(type); switch (eventPhase) { case CAPTURING_PHASE: buf.append(", CAPTURING"); break; case AT_TARGET: buf.append(", AT TARGET"); break; case BUBBLING_PHASE: buf.append(", BUBBLING"); break; default: buf.append(", (inactive)"); break; } if (bubbles && eventPhase != BUBBLING_PHASE) { buf.append(", bubbles"); } if (cancelable) { buf.append(", can cancel"); } // were we to provide subclass info, this's where it'd live buf.append("]"); return buf.toString(); } /** * "MutationEvent" implementation. */ public static final class DomMutationEvent extends DomEvent implements MutationEvent { // package private Node relatedNode; // init private String prevValue; // init private String newValue; // init private String attrName; // init private short attrChange; // init /** Returns any "related" node provided by this type of event */ public final Node getRelatedNode() { return relatedNode; } /** Returns any "previous value" provided by this type of event */ public final String getPrevValue() { return prevValue; } /** Returns any "new value" provided by this type of event */ public final String getNewValue() { return newValue; } /** For attribute change events, returns the attribute's name */ public final String getAttrName() { return attrName; } /** For attribute change events, returns how the attribuet changed */ public final short getAttrChange() { return attrChange; } /** Initializes a mutation event */ public final void initMutationEvent(String typeArg, boolean canBubbleArg, boolean cancelableArg, Node relatedNodeArg, String prevValueArg, String newValueArg, String attrNameArg, short attrChangeArg) { // super.initEvent is inlined here for speed // (mutation events are issued on all DOM changes) eventPhase = 0; type = typeArg; bubbles = canBubbleArg; cancelable = cancelableArg; timeStamp = System.currentTimeMillis(); relatedNode = relatedNodeArg; prevValue = prevValueArg; newValue = newValueArg; attrName = attrNameArg; attrChange = attrChangeArg; } // clear everything that should be GC-able void clear() { type = null; target = null; relatedNode = null; currentNode = null; prevValue = newValue = attrName = null; } /** Constructs an uninitialized mutation event. */ public DomMutationEvent(String type) { super(type); } } /** * "UIEvent" implementation. */ public static class DomUIEvent extends DomEvent implements UIEvent { private AbstractView view; // init private int detail; // init /** Constructs an uninitialized User Interface (UI) event */ public DomUIEvent (String type) { super (type); } public final AbstractView getView () { return view; } public final int getDetail () { return detail; } /** Initializes a UI event */ public final void initUIEvent(String typeArg, boolean canBubbleArg, boolean cancelableArg, AbstractView viewArg, int detailArg) { super.initEvent(typeArg, canBubbleArg, cancelableArg); view = viewArg; detail = detailArg; } } /* static final class DomMouseEvent extends DomUIEvent implements MouseEvent { // another half dozen state variables/accessors } */ }