src/org/xwt/Trap.java

   1 // Copyright 2002 Adam Megacz, see the COPYING file for licensing [GPL]
   2 package org.xwt;
   3
   4 import java.util.*;
   5 import org.xwt.js.*;
   6 import org.xwt.util.*;
   7
   8 /**
   9  *  This class encapsulates a single trap placed on a given node. The
  10  *  traps for a given property name on a given box are maintained as a
  11  *  linked list stack, with the most recently placed trap at the head
  12  *  of the list.
  13  */
  14 public class Trap {
  15
  16     // Static Data //////////////////////////////////////////////////////////////
  17
  18     /** a vector of weak references to all instances of Trap; used for retheming */
  19     private static Hashtable allTraps = new Hashtable(1000);
  20
  21     /** List of properties that cannot be trapped */
  22     private static final Hash PROHIBITED = new Hash(120, 3);
  23
  24     static {
  25         String[] p = new String[] {
  26             "sizetoimage", "shrink", "hshrink", "vshrink", "x", "y", "width", "height",
  27             "flex", "hflex", "vflex", /*"cols", "rows",*/ "align", "invisible", "absolute", "globalx", "globaly",
  28             "minwidth", "minheight", "height", "width", "maxwidth", "maxheight",
  29             "numchildren", "hpad", "vpad", "doublebuffered", "cursor",
  30             "mousex", "mousey", "xwt", "static", "mouseinside", "root", "thisbox", "indexof", "svg"
  31         };
  32         for(int i=0; i<p.length; i++) PROHIBITED.put(p[i], Boolean.TRUE);
  33     };
  34
  35     private static Object dummy = new Object();
  36
  37
  38     // Instance Members ////////////////////////////////////////////////////////
  39
  40     /** the box on which this trap was placed */
  41     private Box trapee = null;
  42
  43     /** If this trap was actually placed on a root proxy, this is a reference to the proxy */
  44     private JS rp = null;
  45
  46     /** the function for this trap */
  47     JS.CompiledFunction f = null;
  48
  49     /** the name of the property that this trap was placed on */
  50     private String name = null;
  51
  52     /** the next trap down the trap stack */
  53     private Trap next = null;
  54
  55     /** true if this is a read-trap */
  56     boolean isreadtrap = false;
  57
  58     /** The nodeName of the Template whose script placed the trap. See Template.nodeName for more detail. */
  59     private String placerNodeName = null;
  60
  61     /** our weak reference in the allTraps Hash */
  62     private Weak myWeak = Platform.getWeak(this);
  63
  64
  65     // Static Methods //////////////////////////////////////////////////////////////////////////
  66
  67     /**
  68      *  adds a trap.
  69      *  @param trapee the box to place the trap on
  70      *  @param name the name of the property to trap on
  71      *  @param f the function to place as a trap
  72      *  @param isreadtrap true iff this is a read (double-underscore) trap
  73      *  @param rp if this trap is being placed via a rootproxy, this is that proxy object.
  74      */
  75     static void addTrap(Box trapee, String name, JS.CompiledFunction f, boolean isreadtrap, JS rp) {
  76
  77         if (PROHIBITED.get(name) != null || name.startsWith("xwt_")) {
  78             Log.log(Trap.class, "Error: you cannot place traps on special property \"" + name + "\"");
  79             return;
  80         }
  81
  82         // find out what script is currently running
  83         JS.CompiledFunction placer = JS.Thread.fromJavaThread(java.lang.Thread.currentThread()).getCurrentCompiledFunction();
  84         if (placer == null) { Log.log(Trap.class, "placer is null"); return; }
  85         String placerNodeName = placer.getSourceName();
  86
  87         // check if this script has already placed a trap on this property
  88         if (trapee.traps == null) trapee.traps = new Hash(10, 3);
  89         for(Trap t = (Trap)trapee.traps.get(name); t != null; t = t.next) if (t.placerNodeName.equals(placerNodeName)) return;
  90
  91         // actually place the trap
  92         Trap t = new Trap();
  93         t.next = (Trap)trapee.traps.get(name);
  94         trapee.traps.put(name, t);
  95         t.trapee = trapee;
  96         t.f = f;
  97         t.placerNodeName = placerNodeName;
  98         t.rp = rp;
  99         t.name = name;
 100         t.isreadtrap = isreadtrap;
 101
 102         // make sure that the surface knows when we place traps on these two properties (slightly inelegant)
 103         if (trapee.surface != null && (name.equals("KeyPressed") || name.equals("KeyReleased"))) {
 104             trapee.surface.keywatchers.removeElement(trapee);
 105             trapee.surface.keywatchers.addElement(trapee);
 106         }
 107     }
 108
 109     /** returns the function placed as a trap on property <code>name</code> of box <code>b</code> by the currently-running script */
 110     public static Trap getTrap(Box b, String name) {
 111         if (b.traps == null) return null;
 112
 113         String currentFunctionNodeName = JS.Thread.fromJavaThread(java.lang.Thread.currentThread()).getCurrentCompiledFunction().getSourceName();
 114         for(Trap cur = (Trap)b.traps.get(name); cur != null; cur = cur.next)
 115             if (cur.placerNodeName.equals(currentFunctionNodeName))
 116                 return cur;
 117
 118         return null;
 119     }
 120
 121     // Instance Methods //////////////////////////////////////////////////////////////////////////
 122
 123     private Trap() { allTraps.put(myWeak, dummy); }
 124
 125     /** the empty object, used for get-traps */
 126     public static JS.Array emptyargs = new JS.Array();
 127
 128     /** perform this trap -- arg.length == 0 if this is a get; otherwise it contains a single element to be put */
 129     public Object perform(JS.Array jsArrayArgs) throws JS.Exn {
 130         // TrapContext tc = TrapContext.get();
 131         if (jsArrayArgs == null) jsArrayArgs = emptyargs;
 132         TrapArgs args = new TrapArgs(this,jsArrayArgs);
 133
 134         // invoke the trap function
 135         try {
 136             if (!isreadtrap && args.length() == 0) return cascade(args);
 137
 138             if (f == null) {
 139                 if (Log.verbose) Log.log(this, "debug: reclaimed a dangling trap on property " + name);
 140                 Object ret = cascade(args);
 141                 delete();
 142                 return ret;
 143             }
 144
 145             Object ret = f.call(args);
 146
 147             // autocascade if required
 148             if(args.length() > 0 && !isreadtrap && !args.cascadeHappened) cascade(args);
 149
 150             return ret;
 151
 152         } finally {
 153
 154         }
 155     }
 156
 157     public Object cascade(JS.Array args) {
 158         // if we've hit the end of the trap stack, just do a put(,,,true)
 159         if (next == null) {
 160             if (args.length() == 0) return trapee.get(name, true);
 161             trapee.put(name, args.elementAt(0), true);
 162             return null;
 163         }
 164         return next.perform(args);
 165     }
 166
 167     /** removes this trap */
 168     public void delete() {
 169         for(Trap last = null, cur = (Trap)trapee.traps.get(name); cur != null; last = cur, cur = cur.next) {
 170             if (cur != this) continue;
 171             else if (last != null) last.next = cur.next;
 172             else if (cur.next == null) trapee.traps.remove(name);
 173             else trapee.traps.put(name, cur.next);
 174         }
 175         /* FIXME
 176         if (trapee.surface != null && !trapee.is_trapped("KeyPressed") && !trapee.is_trapped("KeyReleased"))
 177             trapee.surface.keywatchers.removeElement(trapee);
 178         */
 179         allTraps.remove(myWeak);
 180     }
 181
 182     private static class TrapArgs extends JS.Array {
 183         public boolean cascadeHappened;
 184         private Trap t;
 185         public TrapArgs(Trap t,JS.Array args) {
 186             int size = args.length();
 187             setSize(size);
 188             for(int i=0;i<args.length();i++) setElementAt(args.elementAt(i),i);
 189             cascadeHappened = false;
 190             this.t = t;
 191         }
 192
 193         public Object get(Object key) {
 194             // common case
 195             if(!(key instanceof String)) return super.get(key);
 196
 197             if(key.equals("trapee")) return t.trapee;
 198             if(key.equals("trapname")) return t.name;
 199             // FIXME: GETCALL when its available
 200             if(key.equals("cascade")) return new JS.Callable() {
 201                 public Object call(JS.Array args) {
 202                     if(args.length() != 0) cascadeHappened = true;
 203                     return t.cascade(args);
 204                 }
 205             };
 206             return super.get(key);
 207         }
 208     }
 209 }
 210