Source for gnu.xml.dom.DomEvent

   1: /* DomEvent.java -- 
   2:    Copyright (C) 1999,2000,2001 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: package gnu.xml.dom;
  39: 
  40: import org.w3c.dom.*;
  41: import org.w3c.dom.events.*;
  42: import org.w3c.dom.views.AbstractView;        // used by UIEvent
  43: 
  44: /**
  45:  * "Event" implementation.  Events are
  46:  * created (through DocumentEvent interface methods on the document object),
  47:  * and are sent to any target node in the document.
  48:  *
  49:  * <p> Applications may define application specific event subclasses, but
  50:  * should otherwise use the <em>DocumentTraversal</em> interface to acquire
  51:  * event objects.
  52:  *
  53:  * @author David Brownell
  54:  */
  55: public class DomEvent
  56:   implements Event
  57: {
  58:   
  59:   String  type;  // init
  60:   EventTarget  target;
  61:   EventTarget  currentNode;
  62:   short  eventPhase;
  63:   boolean  bubbles; // init
  64:   boolean  cancelable; // init
  65:   long  timeStamp; // ?
  66: 
  67:   /** Returns the event's type (name) as initialized */
  68:   public final String getType()
  69:   {
  70:     return type;
  71:   }
  72: 
  73:   /**
  74:    * Returns event's target; delivery of an event is initiated
  75:    * by a <em>target.dispatchEvent(event)</em> invocation.
  76:    */
  77:   public final EventTarget getTarget()
  78:   {
  79:     return target;
  80:   }
  81: 
  82:   /**
  83:    * Returns the target to which events are currently being
  84:    * delivered.  When capturing or bubbling, this will not
  85:    * be what <em>getTarget</em> returns.
  86:    */
  87:   public final EventTarget getCurrentTarget()
  88:   {
  89:     return currentNode;
  90:   }
  91: 
  92:   /**
  93:    * Returns CAPTURING_PHASE, AT_TARGET, or BUBBLING;
  94:    * only meaningful within EventListener.handleEvent
  95:    */
  96:   public final short getEventPhase()
  97:   {
  98:     return eventPhase;
  99:   }
 100: 
 101:   /**
 102:    * Returns true if the news of the event bubbles to tree tops
 103:    * (as specified during initialization).
 104:    */
 105:   public final boolean getBubbles()
 106:   {
 107:     return bubbles;
 108:   }
 109: 
 110:   /**
 111:    * Returns true if the default handling may be canceled
 112:    * (as specified during initialization).
 113:    */
 114:   public final boolean getCancelable()
 115:   {
 116:     return cancelable;
 117:   }
 118: 
 119:   /**
 120:    * Returns the event's timestamp.
 121:    */
 122:   public final long getTimeStamp()
 123:   {
 124:     return timeStamp;
 125:   }
 126:   
 127:   boolean stop;
 128:   boolean doDefault;
 129:   
 130:   /**
 131:    * Requests the event no longer be captured or bubbled; only
 132:    * listeners on the event target will see the event, if they
 133:    * haven't yet been notified.
 134:    *
 135:    * <p> <em> Avoid using this </em> except for application-specific
 136:    * events, for which you the protocol explicitly "blesses" the use
 137:    * of this with some event types.  Otherwise, you are likely to break
 138:    * algorithms which depend on event notification either directly or
 139:    * through bubbling or capturing.  </p>
 140:    *
 141:    * <p> Note that this method is not final, specifically to enable
 142:    * enforcing of policies about events always propagating. </p>
 143:    */
 144:   public void stopPropagation()
 145:   {
 146:     stop = true;
 147:   }
 148: 
 149:   /**
 150:    * Requests that whoever dispatched the event not perform their
 151:    * default processing when event delivery completes.  Initializes
 152:    * event timestamp.
 153:    */
 154:   public final void preventDefault()
 155:   {
 156:     doDefault = false;
 157:   }
 158: 
 159:   /** Initializes basic event state.  */
 160:   public void initEvent(String typeArg,
 161:                         boolean canBubbleArg,
 162:                         boolean cancelableArg)
 163:   {
 164:     eventPhase = 0;
 165:     type = typeArg;
 166:     bubbles = canBubbleArg;
 167:     cancelable = cancelableArg;
 168:     timeStamp = System.currentTimeMillis();
 169:   }
 170:   
 171:   /** Constructs, but does not initialize, an event. */
 172:   public DomEvent(String type)
 173:   {
 174:     this.type = type;
 175:   }
 176: 
 177:   /**
 178:    * Returns a basic printable description of the event's type,
 179:    * state, and delivery conditions
 180:    */
 181:   public String toString()
 182:   {
 183:     StringBuffer buf = new StringBuffer("[Event ");
 184:     buf.append(type);
 185:     switch (eventPhase)
 186:       {
 187:       case CAPTURING_PHASE:
 188:         buf.append(", CAPTURING");
 189:         break;
 190:       case AT_TARGET:
 191:         buf.append(", AT TARGET");
 192:         break;
 193:       case BUBBLING_PHASE:
 194:         buf.append(", BUBBLING");
 195:         break;
 196:       default:
 197:         buf.append(", (inactive)");
 198:         break;
 199:       }
 200:     if (bubbles && eventPhase != BUBBLING_PHASE)
 201:       {
 202:         buf.append(", bubbles");
 203:       }
 204:     if (cancelable)
 205:       {
 206:         buf.append(", can cancel");
 207:       }
 208:     // were we to provide subclass info, this's where it'd live
 209:     buf.append("]");
 210:     return buf.toString();
 211:   }
 212:   
 213:   /**
 214:    * "MutationEvent" implementation.
 215:    */
 216:   public static final class DomMutationEvent
 217:     extends DomEvent
 218:     implements MutationEvent
 219:   {
 220:     
 221:     // package private
 222:     Node   relatedNode; // init
 223:     
 224:     private String  prevValue; // init
 225:     private String  newValue; // init
 226:     
 227:     private String  attrName; // init
 228:     private short  attrChange; // init
 229:     
 230:     /** Returns any "related" node provided by this type of event */
 231:     public final Node getRelatedNode()
 232:     {
 233:       return relatedNode;
 234:     }
 235:     
 236:     /** Returns any "previous value" provided by this type of event */
 237:     public final String getPrevValue()
 238:     {
 239:       return prevValue;
 240:     }
 241:     
 242:     /** Returns any "new value" provided by this type of event */
 243:     public final String getNewValue()
 244:     {
 245:       return newValue;
 246:     }
 247:     
 248:     /** For attribute change events, returns the attribute's name */
 249:     public final String getAttrName()
 250:     {
 251:       return attrName;
 252:     }
 253:     
 254:     /** For attribute change events, returns how the attribuet changed */
 255:     public final short getAttrChange()
 256:     {
 257:       return attrChange;
 258:     }
 259:     
 260:     /** Initializes a mutation event */
 261:     public final void initMutationEvent(String typeArg,
 262:                                         boolean canBubbleArg,
 263:                                         boolean cancelableArg,
 264:                                         Node relatedNodeArg,
 265:                                         String prevValueArg,
 266:                                         String newValueArg,
 267:                                         String attrNameArg,
 268:                                         short attrChangeArg)
 269:     {
 270:       // super.initEvent is inlined here for speed
 271:       // (mutation events are issued on all DOM changes)
 272:       eventPhase = 0;
 273:       type = typeArg;
 274:       bubbles = canBubbleArg;
 275:       cancelable = cancelableArg;
 276:       timeStamp = System.currentTimeMillis();
 277:       
 278:       relatedNode = relatedNodeArg;
 279:       prevValue = prevValueArg;
 280:       newValue = newValueArg;
 281:       attrName = attrNameArg;
 282:       attrChange = attrChangeArg;
 283:     }
 284: 
 285:     // clear everything that should be GC-able
 286:     void clear()
 287:     {
 288:       type = null;
 289:       target = null;
 290:       relatedNode = null;
 291:       currentNode = null;
 292:       prevValue = newValue = attrName = null;
 293:     }
 294: 
 295:     /** Constructs an uninitialized mutation event. */
 296:     public DomMutationEvent(String type)
 297:     {
 298:       super(type);
 299:     }
 300:   
 301:   }
 302: 
 303:   /**
 304:    * "UIEvent" implementation.
 305:    */
 306:   public static class DomUIEvent
 307:     extends DomEvent
 308:     implements UIEvent
 309:   {
 310:     
 311:     private AbstractView view;  // init
 312:     private int  detail;  // init
 313:     
 314:     /** Constructs an uninitialized User Interface (UI) event */
 315:     public DomUIEvent (String type) { super (type); }
 316:     
 317:     public final AbstractView getView () { return view; }
 318:     public final int getDetail () { return detail; }
 319:     
 320:     /** Initializes a UI event */
 321:     public final void initUIEvent(String typeArg,
 322:                                   boolean canBubbleArg,
 323:                                   boolean cancelableArg,
 324:                                   AbstractView viewArg,
 325:                                   int detailArg)
 326:     {
 327:       super.initEvent(typeArg, canBubbleArg, cancelableArg);
 328:       view = viewArg;
 329:       detail = detailArg;
 330:     }
 331:   
 332:   }
 333: 
 334:     /*
 335: 
 336:     static final class DomMouseEvent extends DomUIEvent
 337:  implements MouseEvent
 338:     {
 339:  // another half dozen state variables/accessors
 340:     }
 341: 
 342:     */
 343: 
 344: }