| /* DomEvent.java -- |
| Copyright (C) 1999,2000,2001 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
| 02111-1307 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| package gnu.xml.dom; |
| |
| import org.w3c.dom.*; |
| import org.w3c.dom.events.*; |
| import org.w3c.dom.views.AbstractView; // used by UIEvent |
| |
| /** |
| * "Event" implementation. Events are |
| * created (through DocumentEvent interface methods on the document object), |
| * and are sent to any target node in the document. |
| * |
| * <p> Applications may define application specific event subclasses, but |
| * should otherwise use the <em>DocumentTraversal</em> 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 <em>target.dispatchEvent(event)</em> 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 <em>getTarget</em> 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. |
| * |
| * <p> <em> Avoid using this </em> 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. </p> |
| * |
| * <p> Note that this method is not final, specifically to enable |
| * enforcing of policies about events always propagating. </p> |
| */ |
| 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() |
| { |
| StringBuffer buf = new StringBuffer("[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 |
| } |
| |
| */ |
| |
| } |
| |
