Fixed frontend properties and updated MochiKit version

22 files changed, 613 insertions, 501 deletions

diff --git a/frontend/gamma/js/MochiKit/Async.js b/frontend/gamma/js/MochiKit/Async.js
index c7408e7..cc43835 100644
--- a/frontend/gamma/js/MochiKit/Async.js
+++ b/frontend/gamma/js/MochiKit/Async.js
@@ -1,576 +1,642 @@
 /***
 
 MochiKit.Async 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Async', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Async', '1.5', ['Base']);
 
 /** @id MochiKit.Async.Deferred */
 MochiKit.Async.Deferred = function (/* optional */ canceller) {
     this.chain = [];
     this.id = this._nextId();
     this.fired = -1;
     this.paused = 0;
     this.results = [null, null];
     this.canceller = canceller;
     this.silentlyCancelled = false;
     this.chained = false;
+    this.finalized = false;
 };
 
 MochiKit.Async.Deferred.prototype = {
     /** @id MochiKit.Async.Deferred.prototype.repr */
     repr: function () {
-        var state;
-        if (this.fired == -1) {
-            state = 'unfired';
-        } else if (this.fired === 0) {
-            state = 'success';
-        } else {
-            state = 'error';
-        }
-        return 'Deferred(' + this.id + ', ' + state + ')';
+        return 'Deferred(' + this.id + ', ' + this.state() + ')';
     },
 
     toString: MochiKit.Base.forwardCall("repr"),
 
     _nextId: MochiKit.Base.counter(),
 
+    /** @id MochiKit.Async.Deferred.prototype.state */
+    state: function () {
+        if (this.fired == -1) {
+            return 'unfired';
+        } else if (this.fired === 0) {
+            return 'success';
+        } else {
+            return 'error';
+        }
+    },
+
     /** @id MochiKit.Async.Deferred.prototype.cancel */
-    cancel: function () {
+    cancel: function (e) {
         var self = MochiKit.Async;
         if (this.fired == -1) {
             if (this.canceller) {
                 this.canceller(this);
             } else {
                 this.silentlyCancelled = true;
             }
             if (this.fired == -1) {
-                this.errback(new self.CancelledError(this));
+                if (typeof(e) === 'string') {
+                    e = new self.GenericError(e);
+                } else if (!(e instanceof Error)) {
+                    e = new self.CancelledError(this);
+                }
+                this.errback(e);
             }
         } else if ((this.fired === 0) && (this.results[0] instanceof self.Deferred)) {
-            this.results[0].cancel();
+            this.results[0].cancel(e);
         }
     },
 
     _resback: function (res) {
         /***
 
         The primitive that means either callback or errback
 
         ***/
         this.fired = ((res instanceof Error) ? 1 : 0);
         this.results[this.fired] = res;
-        this._fire();
+        if (this.paused === 0) {
+            this._fire();
+        }
     },
 
     _check: function () {
         if (this.fired != -1) {
             if (!this.silentlyCancelled) {
                 throw new MochiKit.Async.AlreadyCalledError(this);
             }
             this.silentlyCancelled = false;
             return;
         }
     },
 
     /** @id MochiKit.Async.Deferred.prototype.callback */
     callback: function (res) {
         this._check();
         if (res instanceof MochiKit.Async.Deferred) {
             throw new Error("Deferred instances can only be chained if they are the result of a callback");
         }
         this._resback(res);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.errback */
     errback: function (res) {
         this._check();
         var self = MochiKit.Async;
         if (res instanceof self.Deferred) {
             throw new Error("Deferred instances can only be chained if they are the result of a callback");
         }
         if (!(res instanceof Error)) {
             res = new self.GenericError(res);
         }
         this._resback(res);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.addBoth */
     addBoth: function (fn) {
         if (arguments.length > 1) {
             fn = MochiKit.Base.partial.apply(null, arguments);
         }
         return this.addCallbacks(fn, fn);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.addCallback */
     addCallback: function (fn) {
         if (arguments.length > 1) {
             fn = MochiKit.Base.partial.apply(null, arguments);
         }
         return this.addCallbacks(fn, null);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.addErrback */
     addErrback: function (fn) {
         if (arguments.length > 1) {
             fn = MochiKit.Base.partial.apply(null, arguments);
         }
         return this.addCallbacks(null, fn);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.addCallbacks */
     addCallbacks: function (cb, eb) {
         if (this.chained) {
             throw new Error("Chained Deferreds can not be re-used");
         }
+        if (this.finalized) {
+            throw new Error("Finalized Deferreds can not be re-used");
+        }
         this.chain.push([cb, eb]);
         if (this.fired >= 0) {
             this._fire();
         }
         return this;
     },
 
+    /** @id MochiKit.Async.Deferred.prototype.setFinalizer */
+    setFinalizer: function (fn) {
+        if (this.chained) {
+            throw new Error("Chained Deferreds can not be re-used");
+        }
+        if (this.finalized) {
+            throw new Error("Finalized Deferreds can not be re-used");
+        }
+        if (arguments.length > 1) {
+            fn = MochiKit.Base.partial.apply(null, arguments);
+        }
+        this._finalizer = fn;
+        if (this.fired >= 0) {
+            this._fire();
+        }
+        return this;
+    },
+
     _fire: function () {
         /***
 
         Used internally to exhaust the callback sequence when a result
         is available.
 
         ***/
         var chain = this.chain;
         var fired = this.fired;
         var res = this.results[fired];
         var self = this;
         var cb = null;
         while (chain.length > 0 && this.paused === 0) {
             // Array
             var pair = chain.shift();
             var f = pair[fired];
             if (f === null) {
                 continue;
             }
             try {
                 res = f(res);
                 fired = ((res instanceof Error) ? 1 : 0);
                 if (res instanceof MochiKit.Async.Deferred) {
                     cb = function (res) {
-                        self._resback(res);
                         self.paused--;
-                        if ((self.paused === 0) && (self.fired >= 0)) {
-                            self._fire();
-                        }
+                        self._resback(res);
                     };
                     this.paused++;
                 }
             } catch (err) {
                 fired = 1;
                 if (!(err instanceof Error)) {
                     err = new MochiKit.Async.GenericError(err);
                 }
                 res = err;
             }
         }
         this.fired = fired;
         this.results[fired] = res;
+        if (this.chain.length == 0 && this.paused === 0 && this._finalizer) {
+            this.finalized = true;
+            this._finalizer(res);
+        }
         if (cb && this.paused) {
             // this is for "tail recursion" in case the dependent deferred
             // is already fired
             res.addBoth(cb);
             res.chained = true;
         }
     }
 };
 
 MochiKit.Base.update(MochiKit.Async, {
     /** @id MochiKit.Async.evalJSONRequest */
     evalJSONRequest: function (req) {
         return MochiKit.Base.evalJSON(req.responseText);
     },
 
     /** @id MochiKit.Async.succeed */
     succeed: function (/* optional */result) {
         var d = new MochiKit.Async.Deferred();
         d.callback.apply(d, arguments);
         return d;
     },
 
     /** @id MochiKit.Async.fail */
     fail: function (/* optional */result) {
         var d = new MochiKit.Async.Deferred();
         d.errback.apply(d, arguments);
         return d;
     },
 
     /** @id MochiKit.Async.getXMLHttpRequest */
     getXMLHttpRequest: function () {
         var self = arguments.callee;
         if (!self.XMLHttpRequest) {
             var tryThese = [
                 function () { return new XMLHttpRequest(); },
                 function () { return new ActiveXObject('Msxml2.XMLHTTP'); },
                 function () { return new ActiveXObject('Microsoft.XMLHTTP'); },
                 function () { return new ActiveXObject('Msxml2.XMLHTTP.4.0'); },
                 function () {
                     throw new MochiKit.Async.BrowserComplianceError("Browser does not support XMLHttpRequest");
                 }
             ];
             for (var i = 0; i < tryThese.length; i++) {
                 var func = tryThese[i];
                 try {
                     self.XMLHttpRequest = func;
                     return func();
                 } catch (e) {
                     // pass
                 }
             }
         }
         return self.XMLHttpRequest();
     },
 
     _xhr_onreadystatechange: function (d) {
         // MochiKit.Logging.logDebug('this.readyState', this.readyState);
         var m = MochiKit.Base;
         if (this.readyState == 4) {
             // IE SUCKS
             try {
                 this.onreadystatechange = null;
             } catch (e) {
                 try {
                     this.onreadystatechange = m.noop;
                 } catch (e) {
                 }
             }
             var status = null;
             try {
                 status = this.status;
-                if (!status && m.isNotEmpty(this.responseText)) {
+                if (!status && (this.response || m.isNotEmpty(this.responseText))) {
                     // 0 or undefined seems to mean cached or local
                     status = 304;
                 }
             } catch (e) {
                 // pass
                 // MochiKit.Logging.logDebug('error getting status?', repr(items(e)));
             }
             // 200 is OK, 201 is CREATED, 204 is NO CONTENT
             // 304 is NOT MODIFIED, 1223 is apparently a bug in IE
             if (status == 200 || status == 201 || status == 204 ||
                     status == 304 || status == 1223) {
                 d.callback(this);
             } else {
                 var err = new MochiKit.Async.XMLHttpRequestError(this, "Request failed");
                 if (err.number) {
                     // XXX: This seems to happen on page change
                     d.errback(err);
                 } else {
                     // XXX: this seems to happen when the server is unreachable
                     d.errback(err);
                 }
             }
         }
     },
 
     _xhr_canceller: function (req) {
         // IE SUCKS
         try {
             req.onreadystatechange = null;
         } catch (e) {
             try {
                 req.onreadystatechange = MochiKit.Base.noop;
             } catch (e) {
             }
         }
         req.abort();
     },
 
 
     /** @id MochiKit.Async.sendXMLHttpRequest */
     sendXMLHttpRequest: function (req, /* optional */ sendContent) {
         if (typeof(sendContent) == "undefined" || sendContent === null) {
             sendContent = "";
         }
 
         var m = MochiKit.Base;
         var self = MochiKit.Async;
         var d = new self.Deferred(m.partial(self._xhr_canceller, req));
 
         try {
             req.onreadystatechange = m.bind(self._xhr_onreadystatechange,
                 req, d);
             req.send(sendContent);
         } catch (e) {
             try {
                 req.onreadystatechange = null;
             } catch (ignore) {
                 // pass
             }
             d.errback(e);
         }
 
         return d;
 
     },
 
     /** @id MochiKit.Async.doXHR */
     doXHR: function (url, opts) {
         /*
             Work around a Firefox bug by dealing with XHR during
             the next event loop iteration. Maybe it's this one:
             https://bugzilla.mozilla.org/show_bug.cgi?id=249843
         */
         var self = MochiKit.Async;
         return self.callLater(0, self._doXHR, url, opts);
     },
 
     _doXHR: function (url, opts) {
         var m = MochiKit.Base;
         opts = m.update({
             method: 'GET',
             sendContent: ''
             /*
             queryString: undefined,
             username: undefined,
             password: undefined,
             headers: undefined,
-            mimeType: undefined
+            mimeType: undefined,
+            responseType: undefined
             */
         }, opts);
         var self = MochiKit.Async;
         var req = self.getXMLHttpRequest();
         if (opts.queryString) {
             var qs = m.queryString(opts.queryString);
             if (qs) {
                 url += "?" + qs;
             }
         }
         // Safari will send undefined:undefined, so we have to check.
         // We can't use apply, since the function is native.
         if ('username' in opts) {
             req.open(opts.method, url, true, opts.username, opts.password);
         } else {
             req.open(opts.method, url, true);
         }
         if (req.overrideMimeType && opts.mimeType) {
             req.overrideMimeType(opts.mimeType);
         }
         req.setRequestHeader("X-Requested-With", "XMLHttpRequest");
         if (opts.headers) {
             var headers = opts.headers;
             if (!m.isArrayLike(headers)) {
                 headers = m.items(headers);
             }
             for (var i = 0; i < headers.length; i++) {
                 var header = headers[i];
                 var name = header[0];
                 var value = header[1];
                 req.setRequestHeader(name, value);
             }
         }
+        if ("responseType" in opts && "responseType" in req) {
+            req.responseType = opts.responseType;
+        }
         return self.sendXMLHttpRequest(req, opts.sendContent);
     },
 
     _buildURL: function (url/*, ...*/) {
         if (arguments.length > 1) {
             var m = MochiKit.Base;
             var qs = m.queryString.apply(null, m.extend(null, arguments, 1));
             if (qs) {
                 return url + "?" + qs;
             }
         }
         return url;
     },
 
     /** @id MochiKit.Async.doSimpleXMLHttpRequest */
     doSimpleXMLHttpRequest: function (url/*, ...*/) {
         var self = MochiKit.Async;
         url = self._buildURL.apply(self, arguments);
         return self.doXHR(url);
     },
 
     /** @id MochiKit.Async.loadJSONDoc */
     loadJSONDoc: function (url/*, ...*/) {
         var self = MochiKit.Async;
         url = self._buildURL.apply(self, arguments);
         var d = self.doXHR(url, {
             'mimeType': 'text/plain',
             'headers': [['Accept', 'application/json']]
         });
         d = d.addCallback(self.evalJSONRequest);
         return d;
     },
 
+    /** @id MochiKit.Async.loadScript */
+    loadScript: function (url) {
+        var d = new MochiKit.Async.Deferred();
+        var script = document.createElement("script");
+        script.type = "text/javascript";
+        script.src = url;
+        script.onload = function () {
+            script.onload = null;
+            script.onerror = null;
+            script.onreadystatechange = null;
+            script = null;
+            d.callback();
+        };
+        script.onerror = function (msg) {
+            script.onload = null;
+            script.onerror = null;
+            script.onreadystatechange = null;
+            script = null;
+            msg = "Failed to load script at " + url + ": " + msg;
+            d.errback(new URIError(msg, url));
+        }
+        script.onreadystatechange = function () {
+            if (script.readyState == "loaded" || script.readyState == "complete") {
+                script.onload();
+            } else {
+                // IE doesn't bother to report errors...
+                MochiKit.Async.callLater(10, script.onerror, "Script loading timed out")
+            }
+        };
+        document.getElementsByTagName("head")[0].appendChild(script);
+        return d;
+    },
+
     /** @id MochiKit.Async.wait */
     wait: function (seconds, /* optional */value) {
         var d = new MochiKit.Async.Deferred();
-        var m = MochiKit.Base;
-        if (typeof(value) != 'undefined') {
-            d.addCallback(function () { return value; });
-        }
-        var timeout = setTimeout(
-            m.bind("callback", d),
-            Math.floor(seconds * 1000));
+        var cb = MochiKit.Base.bind("callback", d, value);
+        var timeout = setTimeout(cb, Math.floor(seconds * 1000));
         d.canceller = function () {
             try {
                 clearTimeout(timeout);
             } catch (e) {
                 // pass
             }
         };
         return d;
     },
 
     /** @id MochiKit.Async.callLater */
     callLater: function (seconds, func) {
         var m = MochiKit.Base;
         var pfunc = m.partial.apply(m, m.extend(null, arguments, 1));
         return MochiKit.Async.wait(seconds).addCallback(
             function (res) { return pfunc(); }
         );
     }
 });
 
 
 /** @id MochiKit.Async.DeferredLock */
 MochiKit.Async.DeferredLock = function () {
     this.waiting = [];
     this.locked = false;
     this.id = this._nextId();
 };
 
 MochiKit.Async.DeferredLock.prototype = {
     __class__: MochiKit.Async.DeferredLock,
     /** @id MochiKit.Async.DeferredLock.prototype.acquire */
     acquire: function () {
         var d = new MochiKit.Async.Deferred();
         if (this.locked) {
             this.waiting.push(d);
         } else {
             this.locked = true;
             d.callback(this);
         }
         return d;
     },
     /** @id MochiKit.Async.DeferredLock.prototype.release */
     release: function () {
         if (!this.locked) {
             throw TypeError("Tried to release an unlocked DeferredLock");
         }
         this.locked = false;
         if (this.waiting.length > 0) {
             this.locked = true;
             this.waiting.shift().callback(this);
         }
     },
     _nextId: MochiKit.Base.counter(),
     repr: function () {
         var state;
         if (this.locked) {
             state = 'locked, ' + this.waiting.length + ' waiting';
         } else {
             state = 'unlocked';
         }
         return 'DeferredLock(' + this.id + ', ' + state + ')';
     },
     toString: MochiKit.Base.forwardCall("repr")
 
 };
 
 /** @id MochiKit.Async.DeferredList */
 MochiKit.Async.DeferredList = function (list, /* optional */fireOnOneCallback, fireOnOneErrback, consumeErrors, canceller) {
 
     // call parent constructor
     MochiKit.Async.Deferred.apply(this, [canceller]);
 
     this.list = list;
     var resultList = [];
     this.resultList = resultList;
 
     this.finishedCount = 0;
     this.fireOnOneCallback = fireOnOneCallback;
     this.fireOnOneErrback = fireOnOneErrback;
     this.consumeErrors = consumeErrors;
 
     var cb = MochiKit.Base.bind(this._cbDeferred, this);
     for (var i = 0; i < list.length; i++) {
         var d = list[i];
         resultList.push(undefined);
         d.addCallback(cb, i, true);
         d.addErrback(cb, i, false);
     }
 
     if (list.length === 0 && !fireOnOneCallback) {
         this.callback(this.resultList);
     }
 
 };
 
 MochiKit.Async.DeferredList.prototype = new MochiKit.Async.Deferred();
+MochiKit.Async.DeferredList.prototype.constructor = MochiKit.Async.DeferredList;
 
 MochiKit.Async.DeferredList.prototype._cbDeferred = function (index, succeeded, result) {
     this.resultList[index] = [succeeded, result];
     this.finishedCount += 1;
     if (this.fired == -1) {
         if (succeeded && this.fireOnOneCallback) {
             this.callback([index, result]);
         } else if (!succeeded && this.fireOnOneErrback) {
             this.errback(result);
         } else if (this.finishedCount == this.list.length) {
             this.callback(this.resultList);
         }
     }
     if (!succeeded && this.consumeErrors) {
         result = null;
     }
     return result;
 };
 
 /** @id MochiKit.Async.gatherResults */
 MochiKit.Async.gatherResults = function (deferredList) {
     var d = new MochiKit.Async.DeferredList(deferredList, false, true, false);
     d.addCallback(function (results) {
         var ret = [];
         for (var i = 0; i < results.length; i++) {
             ret.push(results[i][1]);
         }
         return ret;
     });
     return d;
 };
 
 /** @id MochiKit.Async.maybeDeferred */
 MochiKit.Async.maybeDeferred = function (func) {
     var self = MochiKit.Async;
     var result;
     try {
         var r = func.apply(null, MochiKit.Base.extend([], arguments, 1));
         if (r instanceof self.Deferred) {
             result = r;
         } else if (r instanceof Error) {
             result = self.fail(r);
         } else {
             result = self.succeed(r);
         }
     } catch (e) {
         result = self.fail(e);
     }
     return result;
 };
 
 
 MochiKit.Async.__new__ = function () {
     var m = MochiKit.Base;
     var ne = m.partial(m._newNamedError, this);
 
     ne("AlreadyCalledError",
         /** @id MochiKit.Async.AlreadyCalledError */
         function (deferred) {
             /***
 
             Raised by the Deferred if callback or errback happens
             after it was already fired.
 
diff --git a/frontend/gamma/js/MochiKit/Base.js b/frontend/gamma/js/MochiKit/Base.js
index d33c269..ca1734c 100644
--- a/frontend/gamma/js/MochiKit/Base.js
+++ b/frontend/gamma/js/MochiKit/Base.js
@@ -1,116 +1,127 @@
 /***
 
 MochiKit.Base 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-if (typeof(MochiKit) == 'undefined') {
-    MochiKit = {};
-}
+
+// MochiKit module (namespace)
+var MochiKit = MochiKit || {};
 if (typeof(MochiKit.__export__) == "undefined") {
     MochiKit.__export__ = true;
 }
-if (typeof(MochiKit.Base) == 'undefined') {
-    MochiKit.Base = {};
-}
+MochiKit.NAME = "MochiKit";
+MochiKit.VERSION = "1.5";
+MochiKit.__repr__ = function () {
+    return "[" + this.NAME + " " + this.VERSION + "]";
+};
+MochiKit.toString = function () {
+    return this.__repr__();
+};
+
+
+// MochiKit.Base module
+MochiKit.Base = MochiKit.Base || {};
 
 /**
- * Registers a new MochiKit module. This function will insert a new
- * property into the "MochiKit" object, making sure that all
- * dependency modules have already been inserted. It will also make
- * sure that the appropriate properties and default module functions
- * are defined.
+ * Creates a new module in a parent namespace. This function will
+ * create a new empty module object with "NAME", "VERSION",
+ * "toString" and "__repr__" properties. This object will be inserted into the parent object
+ * using the specified name (i.e. parent[name] = module). It will
+ * also verify that all the dependency modules are defined in the
+ * parent, or an error will be thrown.
  *
+ * @param {Object} parent the parent module (use "this" or "window" for
+ *            a global module)
  * @param {String} name the module name, e.g. "Base"
  * @param {String} version the module version, e.g. "1.5"
- * @param {Array} deps the array of module dependencies (as strings)
+ * @param {Array} [deps] the array of module dependencies (as strings)
  */
-MochiKit.Base._module = function (name, version, deps) {
-    if (!(name in MochiKit)) {
-        MochiKit[name] = {};
-    }
-    var module = MochiKit[name];
-    module.NAME = "MochiKit." + name;
+MochiKit.Base.module = function (parent, name, version, deps) {
+    var module = parent[name] = parent[name] || {};
+    var prefix = (parent.NAME ? parent.NAME + "." : "");
+    module.NAME = prefix + name;
     module.VERSION = version;
     module.__repr__ = function () {
         return "[" + this.NAME + " " + this.VERSION + "]";
     };
     module.toString = function () {
         return this.__repr__();
     };
-    for (var i = 0; i < deps.length; i++) {
-        if (!(deps[i] in MochiKit)) {
-            throw 'MochiKit.' + name + ' depends on MochiKit.' + deps[i] + '!';
+    for (var i = 0; deps != null && i < deps.length; i++) {
+        if (!(deps[i] in parent)) {
+            throw module.NAME + ' depends on ' + prefix + deps[i] + '!';
         }
     }
-}
+    return module;
+};
 
-MochiKit.Base._module("Base", "1.5", []);
+MochiKit.Base.module(MochiKit, "Base", "1.5", []);
 
 /** @id MochiKit.Base.update */
 MochiKit.Base.update = function (self, obj/*, ... */) {
     if (self === null || self === undefined) {
         self = {};
     }
     for (var i = 1; i < arguments.length; i++) {
         var o = arguments[i];
         if (typeof(o) != 'undefined' && o !== null) {
             for (var k in o) {
                 self[k] = o[k];
             }
         }
     }
     return self;
 };
 
 MochiKit.Base.update(MochiKit.Base, {
     /** @id MochiKit.Base.camelize */
     camelize: function (selector) {
         /* from dojo.style.toCamelCase */
         var arr = selector.split('-');
         var cc = arr[0];
         for (var i = 1; i < arr.length; i++) {
             cc += arr[i].charAt(0).toUpperCase() + arr[i].substring(1);
         }
         return cc;
     },
 
     /** @id MochiKit.Base.counter */
     counter: function (n/* = 1 */) {
         if (arguments.length === 0) {
             n = 1;
         }
         return function () {
             return n++;
         };
     },
 
     /** @id MochiKit.Base.clone */
     clone: function (obj) {
         var me = arguments.callee;
         if (arguments.length == 1) {
             me.prototype = obj;
             return new me();
         }
     },
     
     _flattenArray: function (res, lst) {
         for (var i = 0; i < lst.length; i++) {
             var o = lst[i];
             if (o instanceof Array) {
                 arguments.callee(res, o);
             } else {
                 res.push(o);
             }
         }
         return res;
     },
 
     /** @id MochiKit.Base.flattenArray */
     flattenArray: function (lst) {
         return MochiKit.Base._flattenArray([], lst);
     },
@@ -179,240 +190,241 @@ MochiKit.Base.update(MochiKit.Base, {
                     if (typeof(self[k]) == 'object' && typeof(v) == 'object') {
                         arguments.callee(self[k], v);
                     } else {
                         self[k] = v;
                     }
                 }
             }
         }
         return self;
     },
 
     /** @id MochiKit.Base.setdefault */
     setdefault: function (self, obj/*, ...*/) {
         if (self === null || self === undefined) {
             self = {};
         }
         for (var i = 1; i < arguments.length; i++) {
             var o = arguments[i];
             for (var k in o) {
                 if (!(k in self)) {
                     self[k] = o[k];
                 }
             }
         }
         return self;
     },
 
     /** @id MochiKit.Base.keys */
     keys: function (obj) {
         var rval = [];
         for (var prop in obj) {
             rval.push(prop);
         }
         return rval;
     },
 
     /** @id MochiKit.Base.values */
     values: function (obj) {
         var rval = [];
         for (var prop in obj) {
             rval.push(obj[prop]);
         }
         return rval;
     },
 
      /** @id MochiKit.Base.items */
     items: function (obj) {
         var rval = [];
         var e;
         for (var prop in obj) {
             var v;
             try {
                 v = obj[prop];
             } catch (e) {
                 continue;
             }
             rval.push([prop, v]);
         }
         return rval;
     },
 
 
     _newNamedError: function (module, name, func) {
         func.prototype = new MochiKit.Base.NamedError(module.NAME + "." + name);
+        func.prototype.constructor = func;
         module[name] = func;
     },
 
 
     /** @id MochiKit.Base.operator */
     operator: {
         // unary logic operators
         /** @id MochiKit.Base.truth */
         truth: function (a) { return !!a; },
         /** @id MochiKit.Base.lognot */
         lognot: function (a) { return !a; },
         /** @id MochiKit.Base.identity */
         identity: function (a) { return a; },
 
         // bitwise unary operators
         /** @id MochiKit.Base.not */
         not: function (a) { return ~a; },
         /** @id MochiKit.Base.neg */
         neg: function (a) { return -a; },
 
         // binary operators
         /** @id MochiKit.Base.add */
         add: function (a, b) { return a + b; },
         /** @id MochiKit.Base.sub */
         sub: function (a, b) { return a - b; },
         /** @id MochiKit.Base.div */
         div: function (a, b) { return a / b; },
         /** @id MochiKit.Base.mod */
         mod: function (a, b) { return a % b; },
         /** @id MochiKit.Base.mul */
         mul: function (a, b) { return a * b; },
 
         // bitwise binary operators
         /** @id MochiKit.Base.and */
         and: function (a, b) { return a & b; },
         /** @id MochiKit.Base.or */
         or: function (a, b) { return a | b; },
         /** @id MochiKit.Base.xor */
         xor: function (a, b) { return a ^ b; },
         /** @id MochiKit.Base.lshift */
         lshift: function (a, b) { return a << b; },
         /** @id MochiKit.Base.rshift */
         rshift: function (a, b) { return a >> b; },
         /** @id MochiKit.Base.zrshift */
         zrshift: function (a, b) { return a >>> b; },
 
         // near-worthless built-in comparators
         /** @id MochiKit.Base.eq */
         eq: function (a, b) { return a == b; },
         /** @id MochiKit.Base.ne */
         ne: function (a, b) { return a != b; },
         /** @id MochiKit.Base.gt */
         gt: function (a, b) { return a > b; },
         /** @id MochiKit.Base.ge */
         ge: function (a, b) { return a >= b; },
         /** @id MochiKit.Base.lt */
         lt: function (a, b) { return a < b; },
         /** @id MochiKit.Base.le */
         le: function (a, b) { return a <= b; },
 
         // strict built-in comparators
         seq: function (a, b) { return a === b; },
         sne: function (a, b) { return a !== b; },
 
         // compare comparators
         /** @id MochiKit.Base.ceq */
         ceq: function (a, b) { return MochiKit.Base.compare(a, b) === 0; },
         /** @id MochiKit.Base.cne */
         cne: function (a, b) { return MochiKit.Base.compare(a, b) !== 0; },
         /** @id MochiKit.Base.cgt */
         cgt: function (a, b) { return MochiKit.Base.compare(a, b) == 1; },
         /** @id MochiKit.Base.cge */
         cge: function (a, b) { return MochiKit.Base.compare(a, b) != -1; },
         /** @id MochiKit.Base.clt */
         clt: function (a, b) { return MochiKit.Base.compare(a, b) == -1; },
         /** @id MochiKit.Base.cle */
         cle: function (a, b) { return MochiKit.Base.compare(a, b) != 1; },
 
         // binary logical operators
         /** @id MochiKit.Base.logand */
         logand: function (a, b) { return a && b; },
         /** @id MochiKit.Base.logor */
         logor: function (a, b) { return a || b; },
         /** @id MochiKit.Base.contains */
         contains: function (a, b) { return b in a; }
     },
 
     /** @id MochiKit.Base.forwardCall */
     forwardCall: function (func) {
         return function () {
             return this[func].apply(this, arguments);
         };
     },
 
     /** @id MochiKit.Base.itemgetter */
     itemgetter: function (func) {
         return function (arg) {
             return arg[func];
         };
     },
 
     /** @id MochiKit.Base.bool */
     bool: function (value) {
         if (typeof(value) === "boolean" || value instanceof Boolean) {
             return value.valueOf();
         } else if (typeof(value) === "string" || value instanceof String) {
             return value.length > 0 && value != "false" && value != "null" &&
                    value != "undefined" && value != "0";
         } else if (typeof(value) === "number" || value instanceof Number) {
             return !isNaN(value) && value != 0;
         } else if (value != null && typeof(value.length) === "number") {
-            return value.length !== 0
+            return value.length !== 0;
         } else {
             return value != null;
         }
     },
 
     /** @id MochiKit.Base.typeMatcher */
     typeMatcher: function (/* typ */) {
         var types = {};
         for (var i = 0; i < arguments.length; i++) {
             var typ = arguments[i];
             types[typ] = typ;
         }
         return function () {
             for (var i = 0; i < arguments.length; i++) {
                 if (!(typeof(arguments[i]) in types)) {
                     return false;
                 }
             }
             return true;
         };
     },
 
     /** @id MochiKit.Base.isNull */
     isNull: function (/* ... */) {
         for (var i = 0; i < arguments.length; i++) {
             if (arguments[i] !== null) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.Base.isUndefinedOrNull */
     isUndefinedOrNull: function (/* ... */) {
         for (var i = 0; i < arguments.length; i++) {
             var o = arguments[i];
             if (!(typeof(o) == 'undefined' || o === null)) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.Base.isEmpty */
     isEmpty: function (obj) {
         return !MochiKit.Base.isNotEmpty.apply(this, arguments);
     },
 
     /** @id MochiKit.Base.isNotEmpty */
     isNotEmpty: function (obj) {
         for (var i = 0; i < arguments.length; i++) {
             var o = arguments[i];
             if (!(o && o.length)) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.Base.isArrayLike */
     isArrayLike: function () {
         for (var i = 0; i < arguments.length; i++) {
             var o = arguments[i];
             var typ = typeof(o);
@@ -614,347 +626,356 @@ MochiKit.Base.update(MochiKit.Base, {
     compose: function (f1, f2/*, f3, ... fN */) {
         var fnlist = [];
         var m = MochiKit.Base;
         if (arguments.length === 0) {
             throw new TypeError("compose() requires at least one argument");
         }
         for (var i = 0; i < arguments.length; i++) {
             var fn = arguments[i];
             if (typeof(fn) != "function") {
                 throw new TypeError(m.repr(fn) + " is not a function");
             }
             fnlist.push(fn);
         }
         return function () {
             var args = arguments;
             for (var i = fnlist.length - 1; i >= 0; i--) {
                 args = [fnlist[i].apply(this, args)];
             }
             return args[0];
         };
     },
 
     /** @id MochiKit.Base.bind */
     bind: function (func, self/* args... */) {
         if (typeof(func) == "string") {
             func = self[func];
         }
         var im_func = func.im_func;
         var im_preargs = func.im_preargs;
         var im_self = func.im_self;
         var m = MochiKit.Base;
         if (typeof(func) == "function" && typeof(func.apply) == "undefined") {
             // this is for cases where JavaScript sucks ass and gives you a
             // really dumb built-in function like alert() that doesn't have
             // an apply
             func = m._wrapDumbFunction(func);
         }
         if (typeof(im_func) != 'function') {
             im_func = func;
         }
         if (typeof(self) != 'undefined') {
             im_self = self;
         }
         if (typeof(im_preargs) == 'undefined') {
             im_preargs = [];
         } else  {
             im_preargs = im_preargs.slice();
         }
         m.extend(im_preargs, arguments, 2);
         var newfunc = function () {
             var args = arguments;
             var me = arguments.callee;
             if (me.im_preargs.length > 0) {
                 args = m.concat(me.im_preargs, args);
             }
             var self = me.im_self;
             if (!self) {
                 self = this;
             }
             return me.im_func.apply(self, args);
         };
         newfunc.im_self = im_self;
         newfunc.im_func = im_func;
         newfunc.im_preargs = im_preargs;
+        if (typeof(im_func.NAME) == 'string') {
+            newfunc.NAME = "bind(" + im_func.NAME + ",...)";
+        }
         return newfunc;
     },
 
     /** @id MochiKit.Base.bindLate */
     bindLate: function (func, self/* args... */) {
         var m = MochiKit.Base;
         var args = arguments;
         if (typeof(func) === "string") {
             args = m.extend([m.forwardCall(func)], arguments, 1);
             return m.bind.apply(this, args);
         }
         return m.bind.apply(this, args);
     },
 
     /** @id MochiKit.Base.bindMethods */
     bindMethods: function (self) {
         var bind = MochiKit.Base.bind;
         for (var k in self) {
             var func = self[k];
             if (typeof(func) == 'function') {
                 self[k] = bind(func, self);
             }
         }
     },
 
     /** @id MochiKit.Base.registerComparator */
     registerComparator: function (name, check, comparator, /* optional */ override) {
         MochiKit.Base.comparatorRegistry.register(name, check, comparator, override);
     },
 
     _primitives: {'boolean': true, 'string': true, 'number': true},
 
     /** @id MochiKit.Base.compare */
     compare: function (a, b) {
         if (a == b) {
             return 0;
         }
         var aIsNull = (typeof(a) == 'undefined' || a === null);
         var bIsNull = (typeof(b) == 'undefined' || b === null);
         if (aIsNull && bIsNull) {
             return 0;
         } else if (aIsNull) {
             return -1;
         } else if (bIsNull) {
             return 1;
         }
         var m = MochiKit.Base;
         // bool, number, string have meaningful comparisons
         var prim = m._primitives;
         if (!(typeof(a) in prim && typeof(b) in prim)) {
             try {
                 return m.comparatorRegistry.match(a, b);
             } catch (e) {
                 if (e != m.NotFound) {
                     throw e;
                 }
             }
         }
         if (a < b) {
             return -1;
         } else if (a > b) {
             return 1;
         }
         // These types can't be compared
         var repr = m.repr;
         throw new TypeError(repr(a) + " and " + repr(b) + " can not be compared");
     },
 
     /** @id MochiKit.Base.compareDateLike */
     compareDateLike: function (a, b) {
         return MochiKit.Base.compare(a.getTime(), b.getTime());
     },
 
     /** @id MochiKit.Base.compareArrayLike */
     compareArrayLike: function (a, b) {
         var compare = MochiKit.Base.compare;
         var count = a.length;
         var rval = 0;
         if (count > b.length) {
             rval = 1;
             count = b.length;
         } else if (count < b.length) {
             rval = -1;
         }
         for (var i = 0; i < count; i++) {
             var cmp = compare(a[i], b[i]);
             if (cmp) {
                 return cmp;
             }
         }
         return rval;
     },
 
     /** @id MochiKit.Base.registerRepr */
     registerRepr: function (name, check, wrap, /* optional */override) {
         MochiKit.Base.reprRegistry.register(name, check, wrap, override);
     },
 
     /** @id MochiKit.Base.repr */
     repr: function (o) {
         if (typeof(o) == "undefined") {
             return "undefined";
         } else if (o === null) {
             return "null";
         }
         try {
             if (typeof(o.__repr__) == 'function') {
                 return o.__repr__();
             } else if (typeof(o.repr) == 'function' && o.repr != arguments.callee) {
                 return o.repr();
             }
             return MochiKit.Base.reprRegistry.match(o);
         } catch (e) {
-            if (typeof(o.NAME) == 'string' && (
-                    o.toString == Function.prototype.toString ||
-                    o.toString == Object.prototype.toString
-                )) {
-                return o.NAME;
+            try {
+                if (typeof(o.NAME) == 'string' && (
+                        o.toString == Function.prototype.toString ||
+                        o.toString == Object.prototype.toString
+                    )) {
+                    return o.NAME;
+                }
+            } catch (ignore) {
             }
         }
         try {
             var ostring = (o + "");
         } catch (e) {
             return "[" + typeof(o) + "]";
         }
         if (typeof(o) == "function") {
             ostring = ostring.replace(/^\s+/, "").replace(/\s+/g, " ");
             ostring = ostring.replace(/,(\S)/, ", $1");
             var idx = ostring.indexOf("{");
             if (idx != -1) {
                 ostring = ostring.substr(0, idx) + "{...}";
             }
         }
         return ostring;
     },
 
     /** @id MochiKit.Base.reprArrayLike */
     reprArrayLike: function (o) {
         var m = MochiKit.Base;
         return "[" + m.map(m.repr, o).join(", ") + "]";
     },
 
     /** @id MochiKit.Base.reprString */
     reprString: function (o) {
         return ('"' + o.replace(/(["\\])/g, '\\$1') + '"'
             ).replace(/[\f]/g, "\\f"
             ).replace(/[\b]/g, "\\b"
             ).replace(/[\n]/g, "\\n"
             ).replace(/[\t]/g, "\\t"
             ).replace(/[\v]/g, "\\v"
             ).replace(/[\r]/g, "\\r");
     },
 
     /** @id MochiKit.Base.reprNumber */
     reprNumber: function (o) {
         return o + "";
     },
 
     /** @id MochiKit.Base.registerJSON */
     registerJSON: function (name, check, wrap, /* optional */override) {
         MochiKit.Base.jsonRegistry.register(name, check, wrap, override);
     },
 
 
     /** @id MochiKit.Base.evalJSON */
-    evalJSON: function () {
-        return eval("(" + MochiKit.Base._filterJSON(arguments[0]) + ")");
+    evalJSON: function (jsonText) {
+        return eval("(" + MochiKit.Base._filterJSON(jsonText) + ")");
     },
 
     _filterJSON: function (s) {
         var m = s.match(/^\s*\/\*(.*)\*\/\s*$/);
-        if (m) {
-            return m[1];
-        }
-        return s;
+        return (m) ? m[1] : s;
     },
 
     /** @id MochiKit.Base.serializeJSON */
     serializeJSON: function (o) {
         var objtype = typeof(o);
         if (objtype == "number" || objtype == "boolean") {
             return o + "";
         } else if (o === null) {
             return "null";
         } else if (objtype == "string") {
             var res = "";
             for (var i = 0; i < o.length; i++) {
                 var c = o.charAt(i);
                 if (c == '\"') {
                     res += '\\"';
                 } else if (c == '\\') {
                     res += '\\\\';
                 } else if (c == '\b') {
                     res += '\\b';
                 } else if (c == '\f') {
                     res += '\\f';
                 } else if (c == '\n') {
                     res += '\\n';
                 } else if (c == '\r') {
                     res += '\\r';
                 } else if (c == '\t') {
                     res += '\\t';
                 } else if (o.charCodeAt(i) <= 0x1F) {
                     var hex = o.charCodeAt(i).toString(16);
                     if (hex.length < 2) {
                         hex = '0' + hex;
                     }
                     res += '\\u00' + hex.toUpperCase();
                 } else {
                     res += c;
                 }
             }
             return '"' + res + '"';
         }
         // recurse
         var me = arguments.callee;
         // short-circuit for objects that support "json" serialization
         // if they return "self" then just pass-through...
         var newObj;
+        if (typeof(o.toJSON) == "function") {
+            newObj = o.toJSON();
+            if (o !== newObj) {
+                return me(newObj);
+            }
+        }
         if (typeof(o.__json__) == "function") {
             newObj = o.__json__();
             if (o !== newObj) {
                 return me(newObj);
             }
         }
         if (typeof(o.json) == "function") {
             newObj = o.json();
             if (o !== newObj) {
                 return me(newObj);
             }
         }
         // array
         if (objtype != "function" && typeof(o.length) == "number") {
             var res = [];
             for (var i = 0; i < o.length; i++) {
                 var val = me(o[i]);
                 if (typeof(val) != "string") {
                     // skip non-serializable values
                     continue;
                 }
                 res.push(val);
             }
             return "[" + res.join(", ") + "]";
         }
         // look in the registry
         var m = MochiKit.Base;
         try {
             newObj = m.jsonRegistry.match(o);
             if (o !== newObj) {
                 return me(newObj);
             }
         } catch (e) {
             if (e != m.NotFound) {
                 // something really bad happened
                 throw e;
             }
         }
         // undefined is outside of the spec
         if (objtype == "undefined") {
             throw new TypeError("undefined can not be serialized as JSON");
         }
         // it's a function with no adapter, bad
         if (objtype == "function") {
             return null;
         }
         // generic object code path
         res = [];
         for (var k in o) {
             var useKey;
             if (typeof(k) == "number") {
                 useKey = '"' + k + '"';
             } else if (typeof(k) == "string") {
                 useKey = me(k);
             } else {
                 // skip non-string or number keys
                 continue;
             }
             val = me(o[k]);
             if (typeof(val) != "string") {
                 // skip non-serializable values
                 continue;
             }
             res.push(useKey + ":" + val);
@@ -1039,129 +1060,129 @@ MochiKit.Base.update(MochiKit.Base, {
         return cur;
     },
 
     /** @id MochiKit.Base.objMax */
     objMax: function (/* obj... */) {
         return MochiKit.Base.listMinMax(1, arguments);
     },
 
     /** @id MochiKit.Base.objMin */
     objMin: function (/* obj... */) {
         return MochiKit.Base.listMinMax(-1, arguments);
     },
 
     /** @id MochiKit.Base.findIdentical */
     findIdentical: function (lst, value, start/* = 0 */, /* optional */end) {
         if (typeof(end) == "undefined" || end === null) {
             end = lst.length;
         }
         if (typeof(start) == "undefined" || start === null) {
             start = 0;
         }
         for (var i = start; i < end; i++) {
             if (lst[i] === value) {
                 return i;
             }
         }
         return -1;
     },
 
     /** @id MochiKit.Base.mean */
     mean: function(/* lst... */) {
         /* http://www.nist.gov/dads/HTML/mean.html */
         var sum = 0;
 
         var m = MochiKit.Base;
         var args = m.extend(null, arguments);
         var count = args.length;
 
         while (args.length) {
             var o = args.shift();
             if (o && typeof(o) == "object" && typeof(o.length) == "number") {
                 count += o.length - 1;
                 for (var i = o.length - 1; i >= 0; i--) {
                     sum += o[i];
                 }
             } else {
                 sum += o;
             }
         }
 
         if (count <= 0) {
             throw new TypeError('mean() requires at least one argument');
         }
 
         return sum/count;
     },
 
     /** @id MochiKit.Base.median */
     median: function(/* lst... */) {
         /* http://www.nist.gov/dads/HTML/median.html */
         var data = MochiKit.Base.flattenArguments(arguments);
         if (data.length === 0) {
             throw new TypeError('median() requires at least one argument');
         }
-        data.sort(compare);
+        data.sort(MochiKit.Base.compare);
         if (data.length % 2 == 0) {
             var upper = data.length / 2;
             return (data[upper] + data[upper - 1]) / 2;
         } else {
             return data[(data.length - 1) / 2];
         }
     },
 
     /** @id MochiKit.Base.findValue */
     findValue: function (lst, value, start/* = 0 */, /* optional */end) {
         if (typeof(end) == "undefined" || end === null) {
             end = lst.length;
         }
         if (typeof(start) == "undefined" || start === null) {
             start = 0;
         }
         var cmp = MochiKit.Base.compare;
         for (var i = start; i < end; i++) {
             if (cmp(lst[i], value) === 0) {
                 return i;
             }
         }
         return -1;
     },
 
     /** @id MochiKit.Base.nodeWalk */
     nodeWalk: function (node, visitor) {
         var nodes = [node];
         var extend = MochiKit.Base.extend;
         while (nodes.length) {
             var res = visitor(nodes.shift());
             if (res) {
                 extend(nodes, res);
             }
         }
     },
 
 
     /** @id MochiKit.Base.nameFunctions */
     nameFunctions: function (namespace) {
         var base = namespace.NAME;
         if (typeof(base) == 'undefined') {
             base = '';
         } else {
             base = base + '.';
         }
         for (var name in namespace) {
             var o = namespace[name];
             if (typeof(o) == 'function' && typeof(o.NAME) == 'undefined') {
                 try {
                     o.NAME = base + name;
                 } catch (e) {
                     // pass
                 }
             }
         }
     },
 
 
     /** @id MochiKit.Base.queryString */
     queryString: function (names, values) {
         // check to see if names is a string or a DOM element, and if
         // MochiKit.DOM is available.  If so, drop it like it's a form
         // Ugliest conditional in MochiKit?  Probably!
@@ -1229,224 +1250,251 @@ MochiKit.Base.update(MochiKit.Base, {
                 var name = decode(pair.shift());
                 if (!name) {
                     continue;
                 }
                 var arr = o[name];
                 if (!(arr instanceof Array)) {
                     arr = [];
                     o[name] = arr;
                 }
                 arr.push(decode(pair.join("=")));
             }
         } else {
             for (var i = 0; i < pairs.length; i++) {
                 pair = pairs[i].split("=");
                 var name = pair.shift();
                 if (!name) {
                     continue;
                 }
                 o[decode(name)] = decode(pair.join("="));
             }
         }
         return o;
     }
 });
 
 /** @id MochiKit.Base.AdapterRegistry */
 MochiKit.Base.AdapterRegistry = function () {
     this.pairs = [];
 };
 
 MochiKit.Base.AdapterRegistry.prototype = {
     /** @id MochiKit.Base.AdapterRegistry.prototype.register */
     register: function (name, check, wrap, /* optional */ override) {
         if (override) {
             this.pairs.unshift([name, check, wrap]);
         } else {
             this.pairs.push([name, check, wrap]);
         }
     },
 
     /** @id MochiKit.Base.AdapterRegistry.prototype.match */
     match: function (/* ... */) {
         for (var i = 0; i < this.pairs.length; i++) {
             var pair = this.pairs[i];
             if (pair[1].apply(this, arguments)) {
                 return pair[2].apply(this, arguments);
             }
         }
         throw MochiKit.Base.NotFound;
     },
 
     /** @id MochiKit.Base.AdapterRegistry.prototype.unregister */
     unregister: function (name) {
         for (var i = 0; i < this.pairs.length; i++) {
             var pair = this.pairs[i];
             if (pair[0] == name) {
                 this.pairs.splice(i, 1);
                 return true;
             }
         }
         return false;
     }
 };
 
-MochiKit.Base._exportSymbols = function (globals, module) {
-    if (MochiKit.__export__ === false || module.__export__ === false) {
-        return;
-    }
-    for (var k in module) {
-        var v = module[k];
-        if (v != null) {
-            var okName = (k[0] !== "_" && k !== "toString");
-            if (v.__export__ === true || (v.__export__ !== false && okName)) {
-                globals[k] = module[k];
+/**
+ * Exports all symbols from one or more modules into the specified
+ * namespace (or scope). This is similar to MochiKit.Base.update(),
+ * except for special handling of the "__export__" flag, contained
+ * sub-modules (exported recursively), and names starting with "_".
+ *
+ * @param {Object} namespace the object or scope to modify
+ * @param {Object} module the module to export
+ */
+MochiKit.Base.moduleExport = function (namespace, module/*, ...*/) {
+    var SKIP = { toString: true, NAME: true, VERSION: true };
+    var mods = MochiKit.Base.extend([], arguments, 1);
+    while ((module = mods.shift()) != null) {
+        for (var k in module) {
+            var v = module[k];
+            if (v != null) {
+                var flagSet = (typeof(v.__export__) == 'boolean');
+                var nameValid = (k[0] !== "_" && !SKIP[k]);
+                if (flagSet ? v.__export__ : nameValid) {
+                    if (typeof(v) == 'object' && v.NAME && v.VERSION) {
+                        mods.push(v);
+                    } else {
+                        namespace[k] = module[k];
+                    }
+                }
             }
         }
     }
+    return namespace;
+};
+
+/**
+ * Identical to moduleExport, but also considers the global and
+ * module-specific "__export__" flag.
+ */
+MochiKit.Base._exportSymbols = function (namespace, module) {
+    if (MochiKit.__export__ !== false && module.__export__ !== false) {
+        MochiKit.Base.moduleExport(namespace, module);
+    }
 };
 
 /**
  * Creates a deprecated function alias in the specified module. The
  * deprecated function will forward all calls and arguments to a
  * target function, while also logging a debug message on the first
  * call (if MochiKit.Logging is loaded). The destination function may
  * be located in another module, which must be loaded, or an
  * exception will be thrown.
  *
  * @param {Object/String} module the source module or module name
  *            (e.g. 'DOM' or 'MochiKit.DOM')
  * @param {String} name the deprecated function name (e.g. 'getStyle')
  * @param {String} target the fully qualified name of the target
  *            function (e.g. 'MochiKit.Style.getStyle')
  * @param {String} version the first version when the source function
  *            was deprecated (e.g. '1.4')
  * @param {Boolean} [exportable] the exportable function flag,
- *            defaults to true
+ *            defaults to false
  */
 MochiKit.Base._deprecated = function (module, name, target, version, exportable) {
     if (typeof(module) === 'string') {
         if (module.indexOf('MochiKit.') === 0) {
             module = module.substring(9);
         }
         module = MochiKit[module];
     }
     var targetModule = target.split('.')[1];
     var targetName = target.split('.')[2];
     var func = function () {
         var self = arguments.callee;
         var msg = module.NAME + '.' + name + ' is deprecated since version ' +
                   version + '. Use ' + target + ' instead.';
         if (self.logged !== true) {
             self.logged = true;
             if (MochiKit.Logging) {
                 MochiKit.Logging.logDebug(msg);
             } else if (console && console.log) {
                 console.log(msg);
             }
         }
         if (!MochiKit[targetModule]) {
             throw new Error(msg);
         }
         return MochiKit[targetModule][targetName].apply(this, arguments);
     };
-    if (exportable === false) {
-        func.__export__ = false;
-    }
+    func.__export__ = (exportable === true);
     module[name] = func;
-}
+};
 
 MochiKit.Base.__new__ = function () {
     var m = this;
 
     /** @id MochiKit.Base.noop */
     m.noop = m.operator.identity;
 
     // Backwards compat
-    m._deprecated(m, 'forward', 'MochiKit.Base.forwardCall', '1.3', false);
-    m._deprecated(m, 'find', 'MochiKit.Base.findValue', '1.3', false);
+    m._deprecated(m, 'forward', 'MochiKit.Base.forwardCall', '1.3');
+    m._deprecated(m, 'find', 'MochiKit.Base.findValue', '1.3');
 
     if (typeof(encodeURIComponent) != "undefined") {
         /** @id MochiKit.Base.urlEncode */
         m.urlEncode = function (unencoded) {
             return encodeURIComponent(unencoded).replace(/\'/g, '%27');
         };
     } else {
         m.urlEncode = function (unencoded) {
             return escape(unencoded
                 ).replace(/\+/g, '%2B'
                 ).replace(/\"/g,'%22'
-                ).rval.replace(/\'/g, '%27');
+                ).replace(/\'/g, '%27');
         };
     }
 
     /** @id MochiKit.Base.NamedError */
     m.NamedError = function (name) {
         this.message = name;
         this.name = name;
     };
     m.NamedError.prototype = new Error();
+    m.NamedError.prototype.constructor = m.NamedError;
     m.update(m.NamedError.prototype, {
         repr: function () {
             if (this.message && this.message != this.name) {
                 return this.name + "(" + m.repr(this.message) + ")";
             } else {
                 return this.name + "()";
             }
         },
         toString: m.forwardCall("repr")
     });
 
     /** @id MochiKit.Base.NotFound */
     m.NotFound = new m.NamedError("MochiKit.Base.NotFound");
 
 
     /** @id MochiKit.Base.listMax */
     m.listMax = m.partial(m.listMinMax, 1);
     /** @id MochiKit.Base.listMin */
     m.listMin = m.partial(m.listMinMax, -1);
 
     /** @id MochiKit.Base.isCallable */
     m.isCallable = m.typeMatcher('function');
     /** @id MochiKit.Base.isUndefined */
     m.isUndefined = m.typeMatcher('undefined');
+    /** @id MochiKit.Base.isValue */
+    m.isValue = m.typeMatcher('boolean', 'number', 'string');
 
     /** @id MochiKit.Base.merge */
     m.merge = m.partial(m.update, null);
     /** @id MochiKit.Base.zip */
     m.zip = m.partial(m.map, null);
 
     /** @id MochiKit.Base.average */
     m.average = m.mean;
 
     /** @id MochiKit.Base.comparatorRegistry */
     m.comparatorRegistry = new m.AdapterRegistry();
     m.registerComparator("dateLike", m.isDateLike, m.compareDateLike);
     m.registerComparator("arrayLike", m.isArrayLike, m.compareArrayLike);
 
     /** @id MochiKit.Base.reprRegistry */
     m.reprRegistry = new m.AdapterRegistry();
     m.registerRepr("arrayLike", m.isArrayLike, m.reprArrayLike);
     m.registerRepr("string", m.typeMatcher("string"), m.reprString);
     m.registerRepr("numbers", m.typeMatcher("number", "boolean"), m.reprNumber);
 
     /** @id MochiKit.Base.jsonRegistry */
     m.jsonRegistry = new m.AdapterRegistry();
 
     m.nameFunctions(this);
 
 };
 
 MochiKit.Base.__new__();
 
 //
 // XXX: Internet Explorer blows
 //
 if (MochiKit.__export__) {
     compare = MochiKit.Base.compare;
     compose = MochiKit.Base.compose;
     serializeJSON = MochiKit.Base.serializeJSON;
     mean = MochiKit.Base.mean;
     median = MochiKit.Base.median;
 }
 
 MochiKit.Base._exportSymbols(this, MochiKit.Base);
diff --git a/frontend/gamma/js/MochiKit/Color.js b/frontend/gamma/js/MochiKit/Color.js
index 27dc2d0..f2a0f67 100644
--- a/frontend/gamma/js/MochiKit/Color.js
+++ b/frontend/gamma/js/MochiKit/Color.js
@@ -1,179 +1,179 @@
 /***
 
 MochiKit.Color 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito and others.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Color', '1.5', ['Base', 'DOM', 'Style']);
+MochiKit.Base.module(MochiKit, 'Color', '1.5', ['Base', 'DOM', 'Style']);
 
 /** @id MochiKit.Color.Color */
 MochiKit.Color.Color = function (red, green, blue, alpha) {
     if (typeof(alpha) == 'undefined' || alpha === null) {
         alpha = 1.0;
     }
     this.rgb = {
         r: red,
         g: green,
         b: blue,
         a: alpha
     };
 };
 
 
 // Prototype methods
 
 MochiKit.Color.Color.prototype = {
 
     __class__: MochiKit.Color.Color,
 
     /** @id MochiKit.Color.Color.prototype.colorWithAlpha */
     colorWithAlpha: function (alpha) {
         var rgb = this.rgb;
         var m = MochiKit.Color;
         return m.Color.fromRGB(rgb.r, rgb.g, rgb.b, alpha);
     },
 
     /** @id MochiKit.Color.Color.prototype.colorWithHue */
     colorWithHue: function (hue) {
         // get an HSL model, and set the new hue...
         var hsl = this.asHSL();
         hsl.h = hue;
         var m = MochiKit.Color;
         // convert back to RGB...
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.colorWithSaturation */
     colorWithSaturation: function (saturation) {
         // get an HSL model, and set the new hue...
         var hsl = this.asHSL();
         hsl.s = saturation;
         var m = MochiKit.Color;
         // convert back to RGB...
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.colorWithLightness */
     colorWithLightness: function (lightness) {
         // get an HSL model, and set the new hue...
         var hsl = this.asHSL();
         hsl.l = lightness;
         var m = MochiKit.Color;
         // convert back to RGB...
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.darkerColorWithLevel */
     darkerColorWithLevel: function (level) {
         var hsl  = this.asHSL();
         hsl.l = Math.max(hsl.l - level, 0);
         var m = MochiKit.Color;
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.lighterColorWithLevel */
     lighterColorWithLevel: function (level) {
         var hsl  = this.asHSL();
         hsl.l = Math.min(hsl.l + level, 1);
         var m = MochiKit.Color;
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.blendedColor */
     blendedColor: function (other, /* optional */ fraction) {
         if (typeof(fraction) == 'undefined' || fraction === null) {
             fraction = 0.5;
         }
         var sf = 1.0 - fraction;
         var s = this.rgb;
         var d = other.rgb;
         var df = fraction;
         return MochiKit.Color.Color.fromRGB(
             (s.r * sf) + (d.r * df),
             (s.g * sf) + (d.g * df),
             (s.b * sf) + (d.b * df),
             (s.a * sf) + (d.a * df)
         );
     },
 
     /** @id MochiKit.Color.Color.prototype.compareRGB */
     compareRGB: function (other) {
         var a = this.asRGB();
         var b = other.asRGB();
         return MochiKit.Base.compare(
             [a.r, a.g, a.b, a.a],
             [b.r, b.g, b.b, b.a]
         );
     },
 
     /** @id MochiKit.Color.Color.prototype.isLight */
     isLight: function () {
-        return this.asHSL().b > 0.5;
+        return this.asHSL().l > 0.5;
     },
 
     /** @id MochiKit.Color.Color.prototype.isDark */
     isDark: function () {
         return (!this.isLight());
     },
 
     /** @id MochiKit.Color.Color.prototype.toHSLString */
     toHSLString: function () {
         var c = this.asHSL();
         var ccc = MochiKit.Color.clampColorComponent;
         var rval = this._hslString;
         if (!rval) {
             var mid = (
                 ccc(c.h, 360).toFixed(0)
                 + "," + ccc(c.s, 100).toPrecision(4) + "%"
                 + "," + ccc(c.l, 100).toPrecision(4) + "%"
             );
             var a = c.a;
             if (a >= 1) {
                 a = 1;
                 rval = "hsl(" + mid + ")";
             } else {
                 if (a <= 0) {
                     a = 0;
                 }
                 rval = "hsla(" + mid + "," + a + ")";
             }
             this._hslString = rval;
         }
         return rval;
     },
 
     /** @id MochiKit.Color.Color.prototype.toRGBString */
     toRGBString: function () {
         var c = this.rgb;
         var ccc = MochiKit.Color.clampColorComponent;
         var rval = this._rgbString;
         if (!rval) {
             var mid = (
                 ccc(c.r, 255).toFixed(0)
                 + "," + ccc(c.g, 255).toFixed(0)
                 + "," + ccc(c.b, 255).toFixed(0)
             );
             if (c.a != 1) {
                 rval = "rgba(" + mid + "," + c.a + ")";
             } else {
                 rval = "rgb(" + mid + ")";
             }
             this._rgbString = rval;
         }
         return rval;
     },
 
     /** @id MochiKit.Color.Color.prototype.asRGB */
     asRGB: function () {
         return MochiKit.Base.clone(this.rgb);
     },
 
     /** @id MochiKit.Color.Color.prototype.toHexString */
     toHexString: function () {
         var m = MochiKit.Color;
         var c = this.rgb;
         var ccc = MochiKit.Color.clampColorComponent;
@@ -580,141 +580,132 @@ MochiKit.Base.update(MochiKit.Color, {
             l: lightness,
             a: alpha
         };
     },
 
     /** @id MochiKit.Color.toColorPart */
     toColorPart: function (num) {
         num = Math.round(num);
         var digits = num.toString(16);
         if (num < 16) {
             return '0' + digits;
         }
         return digits;
     },
 
     __new__: function () {
         var m = MochiKit.Base;
         /** @id MochiKit.Color.Color.fromRGBString */
         this.Color.fromRGBString = m.bind(
             this.Color._fromColorString, this.Color, "rgb", "fromRGB",
             [1.0/255.0, 1.0/255.0, 1.0/255.0, 1]
         );
         /** @id MochiKit.Color.Color.fromHSLString */
         this.Color.fromHSLString = m.bind(
             this.Color._fromColorString, this.Color, "hsl", "fromHSL",
             [1.0/360.0, 0.01, 0.01, 1]
         );
 
         var third = 1.0 / 3.0;
         /** @id MochiKit.Color.colors */
         var colors = {
             // NSColor colors plus transparent
             /** @id MochiKit.Color.blackColor */
             black: [0, 0, 0],
             /** @id MochiKit.Color.blueColor */
             blue: [0, 0, 1],
             /** @id MochiKit.Color.brownColor */
             brown: [0.6, 0.4, 0.2],
             /** @id MochiKit.Color.cyanColor */
             cyan: [0, 1, 1],
             /** @id MochiKit.Color.darkGrayColor */
             darkGray: [third, third, third],
             /** @id MochiKit.Color.grayColor */
             gray: [0.5, 0.5, 0.5],
             /** @id MochiKit.Color.greenColor */
             green: [0, 1, 0],
             /** @id MochiKit.Color.lightGrayColor */
             lightGray: [2 * third, 2 * third, 2 * third],
             /** @id MochiKit.Color.magentaColor */
             magenta: [1, 0, 1],
             /** @id MochiKit.Color.orangeColor */
             orange: [1, 0.5, 0],
             /** @id MochiKit.Color.purpleColor */
             purple: [0.5, 0, 0.5],
             /** @id MochiKit.Color.redColor */
             red: [1, 0, 0],
             /** @id MochiKit.Color.transparentColor */
             transparent: [0, 0, 0, 0],
             /** @id MochiKit.Color.whiteColor */
             white: [1, 1, 1],
             /** @id MochiKit.Color.yellowColor */
             yellow: [1, 1, 0]
         };
 
-        var makeColor = function (name, r, g, b, a) {
-            var rval = this.fromRGB(r, g, b, a);
-            this[name] = function () { return rval; };
-            return rval;
-        };
-
         for (var k in colors) {
             var name = k + "Color";
-            var bindArgs = m.concat(
-                [makeColor, this.Color, name],
-                colors[k]
-            );
-            this.Color[name] = m.bind.apply(null, bindArgs);
+            var value = this.Color.fromRGB.apply(this.Color, colors[k]);
+            this.Color[name] = m.partial(m.operator.identity, value);
         }
 
         var isColor = function () {
             for (var i = 0; i < arguments.length; i++) {
                 if (!(arguments[i] instanceof MochiKit.Color.Color)) {
                     return false;
                 }
             }
             return true;
         };
 
         var compareColor = function (a, b) {
             return a.compareRGB(b);
         };
 
         m.nameFunctions(this);
 
         m.registerComparator(this.Color.NAME, isColor, compareColor);
     }
 });
 
 MochiKit.Color.__new__();
 
 // Full table of css3 X11 colors <http://www.w3.org/TR/css3-color/#X11COLORS>
 
 MochiKit.Color.Color._namedColors = {
     aliceblue: "#f0f8ff",
     antiquewhite: "#faebd7",
     aqua: "#00ffff",
     aquamarine: "#7fffd4",
     azure: "#f0ffff",
     beige: "#f5f5dc",
     bisque: "#ffe4c4",
     black: "#000000",
     blanchedalmond: "#ffebcd",
     blue: "#0000ff",
     blueviolet: "#8a2be2",
     brown: "#a52a2a",
     burlywood: "#deb887",
     cadetblue: "#5f9ea0",
     chartreuse: "#7fff00",
     chocolate: "#d2691e",
     coral: "#ff7f50",
     cornflowerblue: "#6495ed",
     cornsilk: "#fff8dc",
     crimson: "#dc143c",
     cyan: "#00ffff",
     darkblue: "#00008b",
     darkcyan: "#008b8b",
     darkgoldenrod: "#b8860b",
     darkgray: "#a9a9a9",
     darkgreen: "#006400",
     darkgrey: "#a9a9a9",
     darkkhaki: "#bdb76b",
     darkmagenta: "#8b008b",
     darkolivegreen: "#556b2f",
     darkorange: "#ff8c00",
     darkorchid: "#9932cc",
     darkred: "#8b0000",
     darksalmon: "#e9967a",
     darkseagreen: "#8fbc8f",
     darkslateblue: "#483d8b",
     darkslategray: "#2f4f4f",
     darkslategrey: "#2f4f4f",
diff --git a/frontend/gamma/js/MochiKit/DOM.js b/frontend/gamma/js/MochiKit/DOM.js
index af5d46f..944ab78 100644
--- a/frontend/gamma/js/MochiKit/DOM.js
+++ b/frontend/gamma/js/MochiKit/DOM.js
@@ -1,75 +1,75 @@
 /***
 
 MochiKit.DOM 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('DOM', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'DOM', '1.5', ['Base']);
 
 MochiKit.Base.update(MochiKit.DOM, {
 
     /** @id MochiKit.DOM.currentWindow */
     currentWindow: function () {
         return MochiKit.DOM._window;
     },
 
     /** @id MochiKit.DOM.currentDocument */
     currentDocument: function () {
         return MochiKit.DOM._document;
     },
 
     /** @id MochiKit.DOM.withWindow */
     withWindow: function (win, func) {
         var self = MochiKit.DOM;
         var oldDoc = self._document;
         var oldWin = self._window;
         var rval;
         try {
             self._window = win;
             self._document = win.document;
             rval = func();
         } catch (e) {
             self._window = oldWin;
             self._document = oldDoc;
             throw e;
         }
         self._window = oldWin;
         self._document = oldDoc;
         return rval;
     },
 
     /** @id MochiKit.DOM.formContents  */
     formContents: function (elem/* = document.body */) {
         var names = [];
         var values = [];
         var m = MochiKit.Base;
         var self = MochiKit.DOM;
         if (typeof(elem) == "undefined" || elem === null) {
             elem = self._document.body;
         } else {
             elem = self.getElement(elem);
         }
         m.nodeWalk(elem, function (elem) {
             var name = elem.name;
             if (m.isNotEmpty(name)) {
                 var tagName = elem.tagName.toUpperCase();
                 if (tagName === "INPUT"
                     && (elem.type == "radio" || elem.type == "checkbox")
                     && !elem.checked
                 ) {
                     return null;
                 }
                 if (tagName === "SELECT") {
                     if (elem.type == "select-one") {
                         if (elem.selectedIndex >= 0) {
                             var opt = elem.options[elem.selectedIndex];
                             var v = opt.value;
                             if (!v) {
                                 var h = opt.outerHTML;
                                 // internet explorer sure does suck.
                                 if (h && !h.match(/^[^>]+\svalue\s*=/i)) {
                                     v = opt.text;
@@ -236,183 +236,183 @@ MochiKit.Base.update(MochiKit.DOM, {
         if (typeof(node) == 'undefined' || node === null) {
             return false;
         }
         while (node != null && node !== self._document) {
             if (node === maybeparent) {
                 return true;
             }
             node = node.parentNode;
         }
         return false;
     },
 
     /** @id MochiKit.DOM.setNodeAttribute */
     setNodeAttribute: function (node, attr, value) {
         var o = {};
         o[attr] = value;
         try {
             return MochiKit.DOM.updateNodeAttributes(node, o);
         } catch (e) {
             // pass
         }
         return null;
     },
 
     /** @id MochiKit.DOM.getNodeAttribute */
     getNodeAttribute: function (node, attr) {
         var self = MochiKit.DOM;
         var rename = self.attributeArray.renames[attr];
         var ignoreValue = self.attributeArray.ignoreAttr[attr];
         node = self.getElement(node);
         try {
             if (rename) {
                 return node[rename];
             }
             var value = node.getAttribute(attr);
             if (value != ignoreValue) {
                 return value;
             }
         } catch (e) {
             // pass
         }
         return null;
     },
 
     /** @id MochiKit.DOM.removeNodeAttribute */
     removeNodeAttribute: function (node, attr) {
         var self = MochiKit.DOM;
         var rename = self.attributeArray.renames[attr];
         node = self.getElement(node);
         try {
             if (rename) {
                 return node[rename];
             }
             return node.removeAttribute(attr);
         } catch (e) {
             // pass
         }
         return null;
     },
 
     /** @id MochiKit.DOM.updateNodeAttributes */
     updateNodeAttributes: function (node, attrs) {
         var elem = node;
         var self = MochiKit.DOM;
+        var base = MochiKit.Base;
         if (typeof(node) == 'string') {
             elem = self.getElement(node);
         }
         if (attrs) {
-            var updatetree = MochiKit.Base.updatetree;
             if (self.attributeArray.compliant) {
                 // not IE, good.
                 for (var k in attrs) {
                     var v = attrs[k];
                     if (typeof(v) == 'object' && typeof(elem[k]) == 'object') {
                         if (k == "style" && MochiKit.Style) {
                             MochiKit.Style.setStyle(elem, v);
                         } else {
-                            updatetree(elem[k], v);
+                            base.updatetree(elem[k], v);
                         }
                     } else if (k.substring(0, 2) == "on") {
                         if (typeof(v) == "string") {
                             v = new Function(v);
                         }
                         elem[k] = v;
                     } else {
                         elem.setAttribute(k, v);
                     }
-                    if (typeof(elem[k]) == "string" && elem[k] != v) {
-                        // Also set property for weird attributes (see #302)
+                    if (base.isValue(elem[k]) && elem[k] != v) {
+                        // Also set property for weird attributes (see #302 & #335)
                         elem[k] = v;
                     }
                 }
             } else {
                 // IE is insane in the membrane
                 var renames = self.attributeArray.renames;
                 for (var k in attrs) {
                     v = attrs[k];
                     var renamed = renames[k];
                     if (k == "style" && typeof(v) == "string") {
                         elem.style.cssText = v;
                     } else if (typeof(renamed) == "string") {
                         elem[renamed] = v;
                     } else if (typeof(elem[k]) == 'object'
                             && typeof(v) == 'object') {
                         if (k == "style" && MochiKit.Style) {
                             MochiKit.Style.setStyle(elem, v);
                         } else {
-                            updatetree(elem[k], v);
+                            base.updatetree(elem[k], v);
                         }
                     } else if (k.substring(0, 2) == "on") {
                         if (typeof(v) == "string") {
                             v = new Function(v);
                         }
                         elem[k] = v;
                     } else {
                         elem.setAttribute(k, v);
                     }
-                    if (typeof(elem[k]) == "string" && elem[k] != v) {
-                        // Also set property for weird attributes (see #302)
+                    if (base.isValue(elem[k]) && elem[k] != v) {
+                        // Also set property for weird attributes (see #302 & #335)
                         elem[k] = v;
                     }
                 }
             }
         }
         return elem;
     },
 
     /** @id MochiKit.DOM.appendChildNodes */
     appendChildNodes: function (node/*, nodes...*/) {
         var elem = node;
         var self = MochiKit.DOM;
         if (typeof(node) == 'string') {
             elem = self.getElement(node);
         }
         var nodeStack = [
             self.coerceToDOM(
                 MochiKit.Base.extend(null, arguments, 1),
                 elem
             )
         ];
         var concat = MochiKit.Base.concat;
         while (nodeStack.length) {
             var n = nodeStack.shift();
             if (typeof(n) == 'undefined' || n === null) {
                 // pass
             } else if (typeof(n.nodeType) == 'number') {
                 elem.appendChild(n);
             } else {
                 nodeStack = concat(n, nodeStack);
             }
         }
         return elem;
     },
 
 
     /** @id MochiKit.DOM.insertSiblingNodesBefore */
     insertSiblingNodesBefore: function (node/*, nodes...*/) {
         var elem = node;
         var self = MochiKit.DOM;
         if (typeof(node) == 'string') {
             elem = self.getElement(node);
         }
         var nodeStack = [
             self.coerceToDOM(
                 MochiKit.Base.extend(null, arguments, 1),
                 elem
             )
         ];
         var parentnode = elem.parentNode;
         var concat = MochiKit.Base.concat;
         while (nodeStack.length) {
             var n = nodeStack.shift();
             if (typeof(n) == 'undefined' || n === null) {
                 // pass
             } else if (typeof(n.nodeType) == 'number') {
                 parentnode.insertBefore(n, elem);
             } else {
                 nodeStack = concat(n, nodeStack);
             }
         }
         return parentnode;
     },
 
@@ -929,216 +929,251 @@ MochiKit.Base.update(MochiKit.DOM, {
         if (elem) {
             elem = elem.parentNode;
         }
         while (elem && elem.tagName) {
             var curTagName = elem.tagName.toUpperCase();
             if ((tagName === '*' || tagName == curTagName) &&
                 (className === null || self.hasElementClass(elem, className))) {
                 return elem;
             }
             elem = elem.parentNode;
         }
         return null;
     },
 
     __new__: function (win) {
 
         var m = MochiKit.Base;
         if (typeof(document) != "undefined") {
             this._document = document;
             var kXULNSURI = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
             this._xhtml = (document.documentElement &&
                 document.createElementNS &&
                 document.documentElement.namespaceURI === kXULNSURI);
         } else if (MochiKit.MockDOM) {
             this._document = MochiKit.MockDOM.document;
         }
         this._window = win;
 
         this.domConverters = new m.AdapterRegistry();
 
         var __tmpElement = this._document.createElement("span");
         var attributeArray;
         if (__tmpElement && __tmpElement.attributes &&
                 __tmpElement.attributes.length > 0) {
             // for braindead browsers (IE) that insert extra junk
             var filter = m.filter;
             attributeArray = function (node) {
                 /***
 
                     Return an array of attributes for a given node,
                     filtering out attributes that don't belong for
                     that are inserted by "Certain Browsers".
 
                 ***/
                 return filter(attributeArray.ignoreAttrFilter, node.attributes);
             };
             attributeArray.ignoreAttr = {};
             var attrs = __tmpElement.attributes;
             var ignoreAttr = attributeArray.ignoreAttr;
             for (var i = 0; i < attrs.length; i++) {
                 var a = attrs[i];
                 ignoreAttr[a.name] = a.value;
             }
             attributeArray.ignoreAttrFilter = function (a) {
                 return (attributeArray.ignoreAttr[a.name] != a.value);
             };
             attributeArray.compliant = false;
             attributeArray.renames = {
                 "class": "className",
                 "checked": "defaultChecked",
                 "usemap": "useMap",
                 "for": "htmlFor",
                 "readonly": "readOnly",
                 "colspan": "colSpan",
+                "rowspan": "rowSpan",
                 "bgcolor": "bgColor",
                 "cellspacing": "cellSpacing",
                 "cellpadding": "cellPadding"
             };
         } else {
             attributeArray = function (node) {
                 return node.attributes;
             };
             attributeArray.compliant = true;
             attributeArray.ignoreAttr = {};
             attributeArray.renames = {};
         }
         attributeArray.__export__ = false;
         this.attributeArray = attributeArray;
 
         // Backwards compatibility aliases
         /** @id MochiKit.DOM.computedStyle  */
-        m._deprecated(this, 'computedStyle', 'MochiKit.Style.getStyle', '1.4');
+        m._deprecated(this, 'computedStyle', 'MochiKit.Style.getStyle', '1.4', true);
         /** @id MochiKit.DOM.elementDimensions  */
         m._deprecated(this, 'elementDimensions', 'MochiKit.Style.getElementDimensions', '1.4');
         /** @id MochiKit.DOM.elementPosition  */
         m._deprecated(this, 'elementPosition', 'MochiKit.Style.getElementPosition', '1.4');
         /** @id MochiKit.DOM.getViewportDimensions */
         m._deprecated(this, 'getViewportDimensions', 'MochiKit.Style.getViewportDimensions', '1.4');
         /** @id MochiKit.DOM.hideElement */
         m._deprecated(this, 'hideElement', 'MochiKit.Style.hideElement', '1.4');
         /** @id MochiKit.DOM.makeClipping */
         m._deprecated(this, 'makeClipping', 'MochiKit.Style.makeClipping', '1.4.1');
         /** @id MochiKit.DOM.makePositioned */
         m._deprecated(this, 'makePositioned', 'MochiKit.Style.makePositioned', '1.4.1');
         /** @id MochiKit.DOM.setElementDimensions */
         m._deprecated(this, 'setElementDimensions', 'MochiKit.Style.setElementDimensions', '1.4');
         /** @id MochiKit.DOM.setElementPosition */
         m._deprecated(this, 'setElementPosition', 'MochiKit.Style.setElementPosition', '1.4');
         /** @id MochiKit.DOM.setDisplayForElement */
         m._deprecated(this, 'setDisplayForElement', 'MochiKit.Style.setDisplayForElement', '1.4');
         /** @id MochiKit.DOM.setOpacity */
         m._deprecated(this, 'setOpacity', 'MochiKit.Style.setOpacity', '1.4');
         /** @id MochiKit.DOM.showElement */
         m._deprecated(this, 'showElement', 'MochiKit.Style.showElement', '1.4');
         /** @id MochiKit.DOM.undoClipping */
         m._deprecated(this, 'undoClipping', 'MochiKit.Style.undoClipping', '1.4.1');
         /** @id MochiKit.DOM.undoPositioned */
         m._deprecated(this, 'undoPositioned', 'MochiKit.Style.undoPositioned', '1.4.1');
         /** @id MochiKit.DOM.Coordinates */
         m._deprecated(this, 'Coordinates', 'MochiKit.Style.Coordinates', '1.4');
         /** @id MochiKit.DOM.Dimensions */
         m._deprecated(this, 'Dimensions', 'MochiKit.Style.Dimensions', '1.4');
 
         // shorthand for createDOM syntax
         var createDOMFunc = this.createDOMFunc;
-        /** @id MochiKit.DOM.UL */
-        this.UL = createDOMFunc("ul");
-        /** @id MochiKit.DOM.OL */
-        this.OL = createDOMFunc("ol");
-        /** @id MochiKit.DOM.LI */
-        this.LI = createDOMFunc("li");
-        /** @id MochiKit.DOM.DL */
-        this.DL = createDOMFunc("dl");
-        /** @id MochiKit.DOM.DT */
-        this.DT = createDOMFunc("dt");
-        /** @id MochiKit.DOM.DD */
-        this.DD = createDOMFunc("dd");
-        /** @id MochiKit.DOM.TD */
-        this.TD = createDOMFunc("td");
-        /** @id MochiKit.DOM.TR */
-        this.TR = createDOMFunc("tr");
-        /** @id MochiKit.DOM.TBODY */
-        this.TBODY = createDOMFunc("tbody");
-        /** @id MochiKit.DOM.THEAD */
-        this.THEAD = createDOMFunc("thead");
-        /** @id MochiKit.DOM.TFOOT */
-        this.TFOOT = createDOMFunc("tfoot");
-        /** @id MochiKit.DOM.TABLE */
-        this.TABLE = createDOMFunc("table");
-        /** @id MochiKit.DOM.TH */
-        this.TH = createDOMFunc("th");
-        /** @id MochiKit.DOM.INPUT */
-        this.INPUT = createDOMFunc("input");
-        /** @id MochiKit.DOM.SPAN */
-        this.SPAN = createDOMFunc("span");
         /** @id MochiKit.DOM.A */
         this.A = createDOMFunc("a");
-        /** @id MochiKit.DOM.DIV */
-        this.DIV = createDOMFunc("div");
-        /** @id MochiKit.DOM.IMG */
-        this.IMG = createDOMFunc("img");
+        /** @id MochiKit.DOM.ARTICLE */
+        this.ARTICLE = createDOMFunc("article");
+        /** @id MochiKit.DOM.ASIDE */
+        this.ASIDE = createDOMFunc("aside");
+        /** @id MochiKit.DOM.BR */
+        this.BR = createDOMFunc("br");
         /** @id MochiKit.DOM.BUTTON */
         this.BUTTON = createDOMFunc("button");
-        /** @id MochiKit.DOM.TT */
-        this.TT = createDOMFunc("tt");
-        /** @id MochiKit.DOM.PRE */
-        this.PRE = createDOMFunc("pre");
+        /** @id MochiKit.DOM.CANVAS */
+        this.CANVAS = createDOMFunc("canvas");
+        /** @id MochiKit.DOM.CAPTION */
+        this.CAPTION = createDOMFunc("caption");
+        /** @id MochiKit.DOM.DD */
+        this.DD = createDOMFunc("dd");
+        /** @id MochiKit.DOM.DIV */
+        this.DIV = createDOMFunc("div");
+        /** @id MochiKit.DOM.DL */
+        this.DL = createDOMFunc("dl");
+        /** @id MochiKit.DOM.DT */
+        this.DT = createDOMFunc("dt");
+        /** @id MochiKit.DOM.FIELDSET */
+        this.FIELDSET = createDOMFunc("fieldset");
+        /** @id MochiKit.DOM.FIGURE */
+        this.FIGURE = createDOMFunc("figure");
+        /** @id MochiKit.DOM.FIGCAPTION */
+        this.FIGCAPTION = createDOMFunc("figcaption");
+        /** @id MochiKit.DOM.FOOTER */
+        this.FOOTER = createDOMFunc("footer");
+        /** @id MochiKit.DOM.FORM */
+        this.FORM = createDOMFunc("form");
         /** @id MochiKit.DOM.H1 */
         this.H1 = createDOMFunc("h1");
         /** @id MochiKit.DOM.H2 */
         this.H2 = createDOMFunc("h2");
         /** @id MochiKit.DOM.H3 */
         this.H3 = createDOMFunc("h3");
         /** @id MochiKit.DOM.H4 */
         this.H4 = createDOMFunc("h4");
         /** @id MochiKit.DOM.H5 */
         this.H5 = createDOMFunc("h5");
         /** @id MochiKit.DOM.H6 */
         this.H6 = createDOMFunc("h6");
-        /** @id MochiKit.DOM.BR */
-        this.BR = createDOMFunc("br");
+        /** @id MochiKit.DOM.HEADER */
+        this.HEADER = createDOMFunc("header");
+        /** @id MochiKit.DOM.HGROUP */
+        this.HGROUP = createDOMFunc("hgroup");
         /** @id MochiKit.DOM.HR */
         this.HR = createDOMFunc("hr");
+        /** @id MochiKit.DOM.IFRAME */
+        this.IFRAME = createDOMFunc("iframe");
+        /** @id MochiKit.DOM.IMG */
+        this.IMG = createDOMFunc("img");
+        /** @id MochiKit.DOM.INPUT */
+        this.INPUT = createDOMFunc("input");
         /** @id MochiKit.DOM.LABEL */
         this.LABEL = createDOMFunc("label");
-        /** @id MochiKit.DOM.TEXTAREA */
-        this.TEXTAREA = createDOMFunc("textarea");
-        /** @id MochiKit.DOM.FORM */
-        this.FORM = createDOMFunc("form");
+        /** @id MochiKit.DOM.LEGEND */
+        this.LEGEND = createDOMFunc("legend");
+        /** @id MochiKit.DOM.LI */
+        this.LI = createDOMFunc("li");
+        /** @id MochiKit.DOM.LINK */
+        this.LINK = createDOMFunc("link");
+        /** @id MochiKit.DOM.MARK */
+        this.MARK = createDOMFunc("mark");
+        /** @id MochiKit.DOM.METER */
+        this.METER = createDOMFunc("meter");
+        /** @id MochiKit.DOM.NAV */
+        this.NAV = createDOMFunc("nav");
+        /** @id MochiKit.DOM.OL */
+        this.OL = createDOMFunc("ol");
+        /** @id MochiKit.DOM.OPTGROUP */
+        this.OPTGROUP = createDOMFunc("optgroup");
+        /** @id MochiKit.DOM.OPTION */
+        this.OPTION = createDOMFunc("option");
         /** @id MochiKit.DOM.P */
         this.P = createDOMFunc("p");
+        /** @id MochiKit.DOM.PRE */
+        this.PRE = createDOMFunc("pre");
+        /** @id MochiKit.DOM.PROGRESS */
+        this.PROGRESS = createDOMFunc("progress");
+        /** @id MochiKit.DOM.SCRIPT */
+        this.SCRIPT = createDOMFunc("script");
+        /** @id MochiKit.DOM.SECTION */
+        this.SECTION = createDOMFunc("section");
         /** @id MochiKit.DOM.SELECT */
         this.SELECT = createDOMFunc("select");
-        /** @id MochiKit.DOM.OPTION */
-        this.OPTION = createDOMFunc("option");
-        /** @id MochiKit.DOM.OPTGROUP */
-        this.OPTGROUP = createDOMFunc("optgroup");
-        /** @id MochiKit.DOM.LEGEND */
-        this.LEGEND = createDOMFunc("legend");
-        /** @id MochiKit.DOM.FIELDSET */
-        this.FIELDSET = createDOMFunc("fieldset");
+        /** @id MochiKit.DOM.SPAN */
+        this.SPAN = createDOMFunc("span");
         /** @id MochiKit.DOM.STRONG */
         this.STRONG = createDOMFunc("strong");
-        /** @id MochiKit.DOM.CANVAS */
-        this.CANVAS = createDOMFunc("canvas");
-
+        /** @id MochiKit.DOM.STYLE */
+        this.STYLE = createDOMFunc("style");
+        /** @id MochiKit.DOM.TABLE */
+        this.TABLE = createDOMFunc("table");
+        /** @id MochiKit.DOM.TBODY */
+        this.TBODY = createDOMFunc("tbody");
+        /** @id MochiKit.DOM.TD */
+        this.TD = createDOMFunc("td");
+        /** @id MochiKit.DOM.TEXTAREA */
+        this.TEXTAREA = createDOMFunc("textarea");
+        /** @id MochiKit.DOM.TFOOT */
+        this.TFOOT = createDOMFunc("tfoot");
+        /** @id MochiKit.DOM.TH */
+        this.TH = createDOMFunc("th");
+        /** @id MochiKit.DOM.THEAD */
+        this.THEAD = createDOMFunc("thead");
+        /** @id MochiKit.DOM.TR */
+        this.TR = createDOMFunc("tr");
+        /** @id MochiKit.DOM.TT */
+        this.TT = createDOMFunc("tt");
+        /** @id MochiKit.DOM.UL */
+        this.UL = createDOMFunc("ul");
+        /** @id MochiKit.DOM.NBSP */
+        this.NBSP = "\u00a0";
         /** @id MochiKit.DOM.$ */
         this.$ = this.getElement;
 
         m.nameFunctions(this);
-
     }
 });
 
 
 MochiKit.DOM.__new__(((typeof(window) == "undefined") ? this : window));
 
 //
 // XXX: Internet Explorer blows
 //
 if (MochiKit.__export__) {
     withWindow = MochiKit.DOM.withWindow;
     withDocument = MochiKit.DOM.withDocument;
 }
 
 MochiKit.Base._exportSymbols(this, MochiKit.DOM);
diff --git a/frontend/gamma/js/MochiKit/DateTime.js b/frontend/gamma/js/MochiKit/DateTime.js
index c7b2d25..658084c 100644
--- a/frontend/gamma/js/MochiKit/DateTime.js
+++ b/frontend/gamma/js/MochiKit/DateTime.js
@@ -1,173 +1,176 @@
 /***
 
 MochiKit.DateTime 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('DateTime', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'DateTime', '1.5', ['Base']);
 
 /** @id MochiKit.DateTime.isoDate */
 MochiKit.DateTime.isoDate = function (str) {
     str = str + "";
     if (typeof(str) != "string" || str.length === 0) {
         return null;
     }
     var iso = str.split('-');
     if (iso.length === 0) {
         return null;
     }
-	var date = new Date(iso[0], iso[1] - 1, iso[2]);
-	date.setFullYear(iso[0]);
-	date.setMonth(iso[1] - 1);
-	date.setDate(iso[2]);
+    var date = new Date(parseInt(iso[0], 10), parseInt(iso[1], 10) - 1, parseInt(iso[2], 10));
+    date.setFullYear(iso[0]);
+    date.setMonth(iso[1] - 1);
+    date.setDate(iso[2]);
     return date;
 };
 
 MochiKit.DateTime._isoRegexp = /(\d{4,})(?:-(\d{1,2})(?:-(\d{1,2})(?:[T ](\d{1,2}):(\d{1,2})(?::(\d{1,2})(?:\.(\d+))?)?(?:(Z)|([+-])(\d{1,2})(?::(\d{1,2}))?)?)?)?)?/;
 
 /** @id MochiKit.DateTime.isoTimestamp */
 MochiKit.DateTime.isoTimestamp = function (str) {
     str = str + "";
     if (typeof(str) != "string" || str.length === 0) {
         return null;
     }
     var res = str.match(MochiKit.DateTime._isoRegexp);
     if (typeof(res) == "undefined" || res === null) {
         return null;
     }
     var year, month, day, hour, min, sec, msec;
     year = parseInt(res[1], 10);
     if (typeof(res[2]) == "undefined" || res[2] === '') {
         return new Date(year);
     }
     month = parseInt(res[2], 10) - 1;
     day = parseInt(res[3], 10);
     if (typeof(res[4]) == "undefined" || res[4] === '') {
         return new Date(year, month, day);
     }
     hour = parseInt(res[4], 10);
     min = parseInt(res[5], 10);
     sec = (typeof(res[6]) != "undefined" && res[6] !== '') ? parseInt(res[6], 10) : 0;
     if (typeof(res[7]) != "undefined" && res[7] !== '') {
         msec = Math.round(1000.0 * parseFloat("0." + res[7]));
     } else {
         msec = 0;
     }
     if ((typeof(res[8]) == "undefined" || res[8] === '') && (typeof(res[9]) == "undefined" || res[9] === '')) {
         return new Date(year, month, day, hour, min, sec, msec);
     }
     var ofs;
     if (typeof(res[9]) != "undefined" && res[9] !== '') {
         ofs = parseInt(res[10], 10) * 3600000;
         if (typeof(res[11]) != "undefined" && res[11] !== '') {
             ofs += parseInt(res[11], 10) * 60000;
         }
         if (res[9] == "-") {
             ofs = -ofs;
         }
     } else {
         ofs = 0;
     }
     return new Date(Date.UTC(year, month, day, hour, min, sec, msec) - ofs);
 };
 
 /** @id MochiKit.DateTime.toISOTime */
 MochiKit.DateTime.toISOTime = function (date, realISO/* = false */) {
     if (typeof(date) == "undefined" || date === null) {
         return null;
     }
-    var hh = date.getHours();
-    var mm = date.getMinutes();
-    var ss = date.getSeconds();
+    var _padTwo = MochiKit.DateTime._padTwo;
+    if (realISO) {
+        // adjust date for UTC timezone
+        date = new Date(date.getTime() + (date.getTimezoneOffset() * 60000));
+    }
     var lst = [
-        ((realISO && (hh < 10)) ? "0" + hh : hh),
-        ((mm < 10) ? "0" + mm : mm),
-        ((ss < 10) ? "0" + ss : ss)
+        (realISO ? _padTwo(date.getHours()) : date.getHours()),
+        _padTwo(date.getMinutes()),
+        _padTwo(date.getSeconds())
     ];
-    return lst.join(":");
+    return lst.join(":") + (realISO ? "Z" : "");
 };
 
 /** @id MochiKit.DateTime.toISOTimeStamp */
 MochiKit.DateTime.toISOTimestamp = function (date, realISO/* = false*/) {
     if (typeof(date) == "undefined" || date === null) {
         return null;
     }
+    var time = MochiKit.DateTime.toISOTime(date, realISO);
     var sep = realISO ? "T" : " ";
-    var foot = realISO ? "Z" : "";
     if (realISO) {
+        // adjust date for UTC timezone
         date = new Date(date.getTime() + (date.getTimezoneOffset() * 60000));
     }
-    return MochiKit.DateTime.toISODate(date) + sep + MochiKit.DateTime.toISOTime(date, realISO) + foot;
+    return MochiKit.DateTime.toISODate(date) + sep + time;
 };
 
 /** @id MochiKit.DateTime.toISODate */
 MochiKit.DateTime.toISODate = function (date) {
     if (typeof(date) == "undefined" || date === null) {
         return null;
     }
     var _padTwo = MochiKit.DateTime._padTwo;
-	var _padFour = MochiKit.DateTime._padFour;
+    var _padFour = MochiKit.DateTime._padFour;
     return [
         _padFour(date.getFullYear()),
         _padTwo(date.getMonth() + 1),
         _padTwo(date.getDate())
     ].join("-");
 };
 
 /** @id MochiKit.DateTime.americanDate */
 MochiKit.DateTime.americanDate = function (d) {
     d = d + "";
     if (typeof(d) != "string" || d.length === 0) {
         return null;
     }
     var a = d.split('/');
     return new Date(a[2], a[0] - 1, a[1]);
 };
 
 MochiKit.DateTime._padTwo = function (n) {
     return (n > 9) ? n : "0" + n;
 };
 
 MochiKit.DateTime._padFour = function(n) {
-	switch(n.toString().length) {
-		case 1: return "000" + n; break;
-		case 2: return "00" + n; break;
-		case 3: return "0" + n; break;
-		case 4:
-		default:
-			return n;
-	}
+    switch(n.toString().length) {
+        case 1: return "000" + n; break;
+        case 2: return "00" + n; break;
+        case 3: return "0" + n; break;
+        case 4:
+        default:
+            return n;
+    }
 };
 
 /** @id MochiKit.DateTime.toPaddedAmericanDate */
 MochiKit.DateTime.toPaddedAmericanDate = function (d) {
     if (typeof(d) == "undefined" || d === null) {
         return null;
     }
     var _padTwo = MochiKit.DateTime._padTwo;
     return [
         _padTwo(d.getMonth() + 1),
         _padTwo(d.getDate()),
         d.getFullYear()
     ].join('/');
 };
 
 /** @id MochiKit.DateTime.toAmericanDate */
 MochiKit.DateTime.toAmericanDate = function (d) {
     if (typeof(d) == "undefined" || d === null) {
         return null;
     }
     return [d.getMonth() + 1, d.getDate(), d.getFullYear()].join('/');
 };
 
 MochiKit.DateTime.__new__ = function () {
     MochiKit.Base.nameFunctions(this);
 };
 
 MochiKit.DateTime.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.DateTime);
diff --git a/frontend/gamma/js/MochiKit/DragAndDrop.js b/frontend/gamma/js/MochiKit/DragAndDrop.js
index 62777c5..cf84f77 100644
--- a/frontend/gamma/js/MochiKit/DragAndDrop.js
+++ b/frontend/gamma/js/MochiKit/DragAndDrop.js
@@ -1,75 +1,75 @@
 /***
 MochiKit.DragAndDrop 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
     Mochi-ized By Thomas Herve (_firstname_@nimail.org)
 
 ***/
 
-MochiKit.Base._module('DragAndDrop', '1.5', ['Base', 'Iter', 'DOM', 'Signal', 'Visual', 'Position']);
+MochiKit.Base.module(MochiKit, 'DragAndDrop', '1.5', ['Base', 'Iter', 'DOM', 'Signal', 'Visual', 'Position']);
 
 MochiKit.DragAndDrop.Droppables = {
     /***
 
     Manage all droppables. Shouldn't be used, use the Droppable object instead.
 
     ***/
     drops: [],
 
     remove: function (element) {
         this.drops = MochiKit.Base.filter(function (d) {
             return d.element != MochiKit.DOM.getElement(element);
         }, this.drops);
     },
 
     register: function (drop) {
         this.drops.push(drop);
     },
 
     unregister: function (drop) {
         this.drops = MochiKit.Base.filter(function (d) {
             return d != drop;
         }, this.drops);
     },
 
     prepare: function (element) {
         MochiKit.Base.map(function (drop) {
             if (drop.isAccepted(element)) {
                 if (drop.options.activeclass) {
                     MochiKit.DOM.addElementClass(drop.element,
                                                  drop.options.activeclass);
                 }
                 drop.options.onactive(drop.element, element);
             }
         }, this.drops);
     },
 
     findDeepestChild: function (drops) {
         var deepest = drops[0];
 
         for (var i = 1; i < drops.length; ++i) {
             if (MochiKit.DOM.isChildNode(drops[i].element, deepest.element)) {
                 deepest = drops[i];
             }
         }
         return deepest;
     },
 
     show: function (point, element) {
         if (!this.drops.length) {
             return;
         }
         var affected = [];
 
         if (this.last_active) {
             this.last_active.deactivate();
         }
         MochiKit.Iter.forEach(this.drops, function (drop) {
             if (drop.isAffected(point, element)) {
                 affected.push(drop);
             }
         });
         if (affected.length > 0) {
             var drop = this.findDeepestChild(affected);
@@ -245,130 +245,131 @@ MochiKit.DragAndDrop.Droppable.prototype = {
         /***
 
         Delete this droppable.
 
         ***/
         MochiKit.DragAndDrop.Droppables.unregister(this);
     },
 
     /** @id MochiKit.DragAndDrop.repr */
     repr: function () {
         return '[' + this.__class__.NAME + ", options:" + MochiKit.Base.repr(this.options) + "]";
     }
 };
 
 MochiKit.DragAndDrop.Draggables = {
     /***
 
     Manage draggables elements. Not intended to direct use.
 
     ***/
     drags: [],
 
     register: function (draggable) {
         if (this.drags.length === 0) {
             var conn = MochiKit.Signal.connect;
             this.eventMouseUp = conn(document, 'onmouseup', this, this.endDrag);
             this.eventMouseMove = conn(document, 'onmousemove', this,
                                        this.updateDrag);
             this.eventKeypress = conn(document, 'onkeypress', this,
                                       this.keyPress);
         }
         this.drags.push(draggable);
     },
 
     unregister: function (draggable) {
         this.drags = MochiKit.Base.filter(function (d) {
             return d != draggable;
         }, this.drags);
         if (this.drags.length === 0) {
             var disc = MochiKit.Signal.disconnect;
             disc(this.eventMouseUp);
             disc(this.eventMouseMove);
             disc(this.eventKeypress);
         }
     },
 
     activate: function (draggable) {
         // allows keypress events if window is not currently focused
         // fails for Safari
         window.focus();
         this.activeDraggable = draggable;
     },
 
     deactivate: function () {
         this.activeDraggable = null;
     },
 
     updateDrag: function (event) {
         if (!this.activeDraggable) {
             return;
         }
         var pointer = event.mouse();
         // Mozilla-based browsers fire successive mousemove events with
         // the same coordinates, prevent needless redrawing (moz bug?)
-        if (this._lastPointer && (MochiKit.Base.repr(this._lastPointer.page) ==
-                                  MochiKit.Base.repr(pointer.page))) {
+        if (this._lastPointer &&
+            this._lastPointer.page.x == pointer.page.x &&
+            this._lastPointer.page.y == pointer.page.y) {
             return;
         }
         this._lastPointer = pointer;
         this.activeDraggable.updateDrag(event, pointer);
     },
 
     endDrag: function (event) {
         if (!this.activeDraggable) {
             return;
         }
         this._lastPointer = null;
         this.activeDraggable.endDrag(event);
         this.activeDraggable = null;
     },
 
     keyPress: function (event) {
         if (this.activeDraggable) {
             this.activeDraggable.keyPress(event);
         }
     },
 
     notify: function (eventName, draggable, event) {
         MochiKit.Signal.signal(this, eventName, draggable, event);
     }
 };
 
 /** @id MochiKit.DragAndDrop.Draggable */
 MochiKit.DragAndDrop.Draggable = function (element, options) {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls(element, options);
     }
     this.__init__(element, options);
 };
 
 MochiKit.DragAndDrop.Draggable.prototype = {
     /***
 
     A draggable object. Simple instantiate :
 
         new MochiKit.DragAndDrop.Draggable('myelement');
 
     ***/
     __class__ : MochiKit.DragAndDrop.Draggable,
 
     __init__: function (element, /* optional */options) {
         var v = MochiKit.Visual;
         var b = MochiKit.Base;
         options = b.update({
 
             /** @id MochiKit.DragAndDrop.handle */
             handle: false,
 
             /** @id MochiKit.DragAndDrop.starteffect */
             starteffect: function (innerelement) {
                 this._savedOpacity = MochiKit.Style.getStyle(innerelement, 'opacity') || 1.0;
                 new v.Opacity(innerelement, {duration:0.2, from:this._savedOpacity, to:0.7});
             },
             /** @id MochiKit.DragAndDrop.reverteffect */
             reverteffect: function (innerelement, top_offset, left_offset) {
                 var dur = Math.sqrt(Math.abs(top_offset^2) +
                           Math.abs(left_offset^2))*0.02;
                 return new v.Move(innerelement,
                             {x: -left_offset, y: -top_offset, duration: dur});
@@ -381,169 +382,168 @@ MochiKit.DragAndDrop.Draggable.prototype = {
 
             /** @id MochiKit.DragAndDrop.onchange */
             onchange: b.noop,
 
             /** @id MochiKit.DragAndDrop.zindex */
             zindex: 1000,
 
             /** @id MochiKit.DragAndDrop.revert */
             revert: false,
 
             /** @id MochiKit.DragAndDrop.scroll */
             scroll: false,
 
             /** @id MochiKit.DragAndDrop.scrollSensitivity */
             scrollSensitivity: 20,
 
             /** @id MochiKit.DragAndDrop.scrollSpeed */
             scrollSpeed: 15,
             // false, or xy or [x, y] or function (x, y){return [x, y];}
 
             /** @id MochiKit.DragAndDrop.snap */
             snap: false
         }, options);
 
         var d = MochiKit.DOM;
         this.element = d.getElement(element);
 
         if (options.handle && (typeof(options.handle) == 'string')) {
             this.handle = d.getFirstElementByTagAndClassName(null,
                                        options.handle, this.element);
         }
         if (!this.handle) {
             this.handle = d.getElement(options.handle);
         }
         if (!this.handle) {
             this.handle = this.element;
         }
 
         if (options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
             options.scroll = d.getElement(options.scroll);
             this._isScrollChild = MochiKit.DOM.isChildNode(this.element, options.scroll);
         }
 
         MochiKit.Style.makePositioned(this.element);  // fix IE
 
         this.delta = this.currentDelta();
         this.options = options;
         this.dragging = false;
 
         this.eventMouseDown = MochiKit.Signal.connect(this.handle,
                               'onmousedown', this, this.initDrag);
         MochiKit.DragAndDrop.Draggables.register(this);
     },
 
     /** @id MochiKit.DragAndDrop.destroy */
     destroy: function () {
         MochiKit.Signal.disconnect(this.eventMouseDown);
         MochiKit.DragAndDrop.Draggables.unregister(this);
     },
 
     /** @id MochiKit.DragAndDrop.currentDelta */
     currentDelta: function () {
         var s = MochiKit.Style.getStyle;
         return [
-          parseInt(s(this.element, 'left') || '0'),
-          parseInt(s(this.element, 'top') || '0')];
+          parseInt(s(this.element, 'left') || '0', 10),
+          parseInt(s(this.element, 'top') || '0', 10)];
     },
 
     /** @id MochiKit.DragAndDrop.initDrag */
     initDrag: function (event) {
         if (!event.mouse().button.left) {
             return;
         }
         // abort on form elements, fixes a Firefox issue
         var src = event.target();
         var tagName = (src.tagName || '').toUpperCase();
         if (tagName === 'INPUT' || tagName === 'SELECT' ||
             tagName === 'OPTION' || tagName === 'BUTTON' ||
             tagName === 'TEXTAREA') {
             return;
         }
 
         if (this._revert) {
             this._revert.cancel();
             this._revert = null;
         }
 
         var pointer = event.mouse();
         var pos = MochiKit.Position.cumulativeOffset(this.element);
         this.offset = [pointer.page.x - pos.x, pointer.page.y - pos.y];
 
         MochiKit.DragAndDrop.Draggables.activate(this);
         event.stop();
     },
 
     /** @id MochiKit.DragAndDrop.startDrag */
     startDrag: function (event) {
         this.dragging = true;
         if (this.options.selectclass) {
             MochiKit.DOM.addElementClass(this.element,
                                          this.options.selectclass);
         }
         if (this.options.zindex) {
-            this.originalZ = parseInt(MochiKit.Style.getStyle(this.element,
-                                      'z-index') || '0');
+            this.originalZ = MochiKit.Style.getStyle(this.element, 'z-index');
             this.element.style.zIndex = this.options.zindex;
         }
 
         if (this.options.ghosting) {
             this._clone = this.element.cloneNode(true);
             this.ghostPosition = MochiKit.Position.absolutize(this.element);
             this.element.parentNode.insertBefore(this._clone, this.element);
         }
 
         if (this.options.scroll) {
             if (this.options.scroll == window) {
                 var where = this._getWindowScroll(this.options.scroll);
                 this.originalScrollLeft = where.left;
                 this.originalScrollTop = where.top;
             } else {
                 this.originalScrollLeft = this.options.scroll.scrollLeft;
                 this.originalScrollTop = this.options.scroll.scrollTop;
             }
         }
 
         MochiKit.DragAndDrop.Droppables.prepare(this.element);
         MochiKit.DragAndDrop.Draggables.notify('start', this, event);
         if (this.options.starteffect) {
             this.options.starteffect(this.element);
         }
     },
 
     /** @id MochiKit.DragAndDrop.updateDrag */
     updateDrag: function (event, pointer) {
         if (!this.dragging) {
             this.startDrag(event);
         }
         MochiKit.Position.prepare();
         MochiKit.DragAndDrop.Droppables.show(pointer, this.element);
         MochiKit.DragAndDrop.Draggables.notify('drag', this, event);
         this.draw(pointer);
         this.options.onchange(this);
 
         if (this.options.scroll) {
             this.stopScrolling();
             var p, q;
             if (this.options.scroll == window) {
                 var s = this._getWindowScroll(this.options.scroll);
                 p = new MochiKit.Style.Coordinates(s.left, s.top);
                 q = new MochiKit.Style.Coordinates(s.left + s.width,
                                                    s.top + s.height);
             } else {
                 p = MochiKit.Position.page(this.options.scroll);
                 p.x += this.options.scroll.scrollLeft;
                 p.y += this.options.scroll.scrollTop;
                 p.x += (window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0);
                 p.y += (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0);
                 q = new MochiKit.Style.Coordinates(p.x + this.options.scroll.offsetWidth,
                                                    p.y + this.options.scroll.offsetHeight);
             }
             var speed = [0, 0];
             if (pointer.page.x > (q.x - this.options.scrollSensitivity)) {
                 speed[0] = pointer.page.x - (q.x - this.options.scrollSensitivity);
             } else if (pointer.page.x < (p.x + this.options.scrollSensitivity)) {
                 speed[0] = pointer.page.x - (p.x + this.options.scrollSensitivity);
             }
             if (pointer.page.y > (q.y - this.options.scrollSensitivity)) {
                 speed[1] = pointer.page.y - (q.y - this.options.scrollSensitivity);
             } else if (pointer.page.y < (p.y + this.options.scrollSensitivity)) {
diff --git a/frontend/gamma/js/MochiKit/Format.js b/frontend/gamma/js/MochiKit/Format.js
index 122845e..58877e7 100644
--- a/frontend/gamma/js/MochiKit/Format.js
+++ b/frontend/gamma/js/MochiKit/Format.js
@@ -1,309 +1,309 @@
 /***
 
 MochiKit.Format 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Format', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Format', '1.5', ['Base']);
 
 MochiKit.Format._numberFormatter = function (placeholder, header, footer, locale, isPercent, precision, leadingZeros, separatorAt, trailingZeros) {
     return function (num) {
         num = parseFloat(num);
         if (typeof(num) == "undefined" || num === null || isNaN(num)) {
             return placeholder;
         }
         var curheader = header;
         var curfooter = footer;
         if (num < 0) {
             num = -num;
         } else {
             curheader = curheader.replace(/-/, "");
         }
         var me = arguments.callee;
         var fmt = MochiKit.Format.formatLocale(locale);
         if (isPercent) {
             num = num * 100.0;
             curfooter = fmt.percent + curfooter;
         }
         num = MochiKit.Format.roundToFixed(num, precision);
         var parts = num.split(/\./);
         var whole = parts[0];
         var frac = (parts.length == 1) ? "" : parts[1];
         var res = "";
         while (whole.length < leadingZeros) {
             whole = "0" + whole;
         }
         if (separatorAt) {
             while (whole.length > separatorAt) {
                 var i = whole.length - separatorAt;
                 //res = res + fmt.separator + whole.substring(i, whole.length);
                 res = fmt.separator + whole.substring(i, whole.length) + res;
                 whole = whole.substring(0, i);
             }
         }
         res = whole + res;
         if (precision > 0) {
             while (frac.length < trailingZeros) {
                 frac = frac + "0";
             }
             res = res + fmt.decimal + frac;
         }
         return curheader + res + curfooter;
     };
 };
 
 /** @id MochiKit.Format.numberFormatter */
 MochiKit.Format.numberFormatter = function (pattern, placeholder/* = "" */, locale/* = "default" */) {
     // http://java.sun.com/docs/books/tutorial/i18n/format/numberpattern.html
     // | 0 | leading or trailing zeros
     // | # | just the number
     // | , | separator
     // | . | decimal separator
     // | % | Multiply by 100 and format as percent
     if (typeof(placeholder) == "undefined") {
         placeholder = "";
     }
     var match = pattern.match(/((?:[0#]+,)?[0#]+)(?:\.([0#]+))?(%)?/);
     if (!match) {
         throw TypeError("Invalid pattern");
     }
     var header = pattern.substr(0, match.index);
     var footer = pattern.substr(match.index + match[0].length);
     if (header.search(/-/) == -1) {
         header = header + "-";
     }
     var whole = match[1];
     var frac = (typeof(match[2]) == "string" && match[2] != "") ? match[2] : "";
     var isPercent = (typeof(match[3]) == "string" && match[3] != "");
     var tmp = whole.split(/,/);
     var separatorAt;
     if (typeof(locale) == "undefined") {
         locale = "default";
     }
     if (tmp.length == 1) {
         separatorAt = null;
     } else {
         separatorAt = tmp[1].length;
     }
     var leadingZeros = whole.length - whole.replace(/0/g, "").length;
     var trailingZeros = frac.length - frac.replace(/0/g, "").length;
     var precision = frac.length;
     var rval = MochiKit.Format._numberFormatter(
         placeholder, header, footer, locale, isPercent, precision,
         leadingZeros, separatorAt, trailingZeros
     );
     var m = MochiKit.Base;
     if (m) {
         var fn = arguments.callee;
         var args = m.concat(arguments);
         rval.repr = function () {
             return [
                 self.NAME,
                 "(",
-                map(m.repr, args).join(", "),
+                m.map(m.repr, args).join(", "),
                 ")"
             ].join("");
         };
     }
     return rval;
 };
 
 /** @id MochiKit.Format.formatLocale */
 MochiKit.Format.formatLocale = function (locale) {
     if (typeof(locale) == "undefined" || locale === null) {
         locale = "default";
     }
     if (typeof(locale) == "string") {
         var rval = MochiKit.Format.LOCALE[locale];
         if (typeof(rval) == "string") {
             rval = arguments.callee(rval);
             MochiKit.Format.LOCALE[locale] = rval;
         }
         return rval;
     } else {
         return locale;
     }
 };
 
 /** @id MochiKit.Format.twoDigitAverage */
 MochiKit.Format.twoDigitAverage = function (numerator, denominator) {
     if (denominator) {
         var res = numerator / denominator;
         if (!isNaN(res)) {
             return MochiKit.Format.twoDigitFloat(res);
         }
     }
     return "0";
 };
 
 /** @id MochiKit.Format.twoDigitFloat */
 MochiKit.Format.twoDigitFloat = function (aNumber) {
-    var res = roundToFixed(aNumber, 2);
+    var res = MochiKit.Format.roundToFixed(aNumber, 2);
     if (res.indexOf(".00") > 0) {
         return res.substring(0, res.length - 3);
     } else if (res.charAt(res.length - 1) == "0") {
         return res.substring(0, res.length - 1);
     } else {
         return res;
     }
 };
 
 /** @id MochiKit.Format.lstrip */
 MochiKit.Format.lstrip = function (str, /* optional */chars) {
     str = str + "";
     if (typeof(str) != "string") {
         return null;
     }
     if (!chars) {
         return str.replace(/^\s+/, "");
     } else {
         return str.replace(new RegExp("^[" + chars + "]+"), "");
     }
 };
 
 /** @id MochiKit.Format.rstrip */
 MochiKit.Format.rstrip = function (str, /* optional */chars) {
     str = str + "";
     if (typeof(str) != "string") {
         return null;
     }
     if (!chars) {
         return str.replace(/\s+$/, "");
     } else {
         return str.replace(new RegExp("[" + chars + "]+$"), "");
     }
 };
 
 /** @id MochiKit.Format.strip */
 MochiKit.Format.strip = function (str, /* optional */chars) {
     var self = MochiKit.Format;
     return self.rstrip(self.lstrip(str, chars), chars);
 };
 
 /** @id MochiKit.Format.truncToFixed */
 MochiKit.Format.truncToFixed = function (aNumber, precision) {
     var fixed = MochiKit.Format._numberToFixed(aNumber, precision);
     var fracPos = fixed.indexOf(".");
     if (fracPos > 0 && fracPos + precision + 1 < fixed.length) {
         fixed = fixed.substring(0, fracPos + precision + 1);
         fixed = MochiKit.Format._shiftNumber(fixed, 0);
     }
     return fixed;
-}
+};
 
 /** @id MochiKit.Format.roundToFixed */
 MochiKit.Format.roundToFixed = function (aNumber, precision) {
     var fixed = MochiKit.Format._numberToFixed(aNumber, precision);
     var fracPos = fixed.indexOf(".");
     if (fracPos > 0 && fracPos + precision + 1 < fixed.length) {
         var str = MochiKit.Format._shiftNumber(fixed, precision);
         str = MochiKit.Format._numberToFixed(Math.round(parseFloat(str)), 0);
         fixed = MochiKit.Format._shiftNumber(str, -precision);
     }
     return fixed;
-}
+};
 
 /**
  * Converts a number to a fixed format string. This function handles
  * conversion of exponents by shifting the decimal point to the left
  * or the right. It also guarantees a specified minimum number of
  * fractional digits (but no maximum).
  *
  * @param {Number} aNumber the number to convert
  * @param {Number} precision the minimum number of decimal digits
  *
  * @return {String} the fixed format number string
  */
 MochiKit.Format._numberToFixed = function (aNumber, precision) {
     var str = aNumber.toString();
     var parts = str.split(/[eE]/);
-    var exp = (parts.length === 1) ? 0 : parseInt(parts[1]) || 0;
+    var exp = (parts.length === 1) ? 0 : parseInt(parts[1], 10) || 0;
     var fixed = MochiKit.Format._shiftNumber(parts[0], exp);
     parts = fixed.split(/\./);
     var whole = parts[0];
     var frac = (parts.length === 1) ? "" : parts[1];
     while (frac.length < precision) {
         frac += "0";
     }
     if (frac.length > 0) {
         return whole + "." + frac;
     } else {
         return whole;
     }
-}
+};
 
 /**
  * Shifts the decimal dot location in a fixed format number string.
  * This function handles negative values and will add and remove
  * leading and trailing zeros as needed.
  *
  * @param {String} num the fixed format number string
  * @param {Number} exp the base-10 exponent to apply
  *
  * @return {String} the new fixed format number string
  */
 MochiKit.Format._shiftNumber = function (num, exp) {
     var pos = num.indexOf(".");
     if (pos < 0) {
         pos = num.length;
     } else {
         num = num.substring(0, pos) + num.substring(pos + 1);
     }
     pos += exp;
     while (pos <= 0 || (pos <= 1 && num.charAt(0) === "-")) {
         if (num.charAt(0) === "-") {
             num = "-0" + num.substring(1);
         } else {
             num = "0" + num;
         }
         pos++;
     }
     while (pos > num.length) {
         num += "0";
     }
     if (pos < num.length) {
         num = num.substring(0, pos) + "." + num.substring(pos);
     }
     while (/^0[^.]/.test(num)) {
         num = num.substring(1);
     }
     while (/^-0[^.]/.test(num)) {
         num = "-" + num.substring(2);
     }
     return num;
-}
+};
 
 /** @id MochiKit.Format.percentFormat */
 MochiKit.Format.percentFormat = function (aNumber) {
     return MochiKit.Format.twoDigitFloat(100 * aNumber) + '%';
 };
 
 MochiKit.Format.LOCALE = {
     en_US: {separator: ",", decimal: ".", percent: "%"},
     de_DE: {separator: ".", decimal: ",", percent: "%"},
     pt_BR: {separator: ".", decimal: ",", percent: "%"},
     fr_FR: {separator: " ", decimal: ",", percent: "%"},
     "default": "en_US",
     __export__: false
 };
 
 MochiKit.Format.__new__ = function () {
     MochiKit.Base.nameFunctions(this);
     var base = this.NAME + ".";
     var k, v, o;
     for (k in this.LOCALE) {
         o = this.LOCALE[k];
         if (typeof(o) == "object") {
             o.repr = function () { return this.NAME; };
             o.NAME = base + "LOCALE." + k;
         }
     }
 };
 
 MochiKit.Format.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.Format);
diff --git a/frontend/gamma/js/MochiKit/Iter.js b/frontend/gamma/js/MochiKit/Iter.js
index 524b2bc..77623bc 100644
--- a/frontend/gamma/js/MochiKit/Iter.js
+++ b/frontend/gamma/js/MochiKit/Iter.js
@@ -1,75 +1,75 @@
 /***
 
 MochiKit.Iter 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Iter', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Iter', '1.5', ['Base']);
 
 MochiKit.Base.update(MochiKit.Iter, {
     /** @id MochiKit.Iter.registerIteratorFactory */
     registerIteratorFactory: function (name, check, iterfactory, /* optional */ override) {
         MochiKit.Iter.iteratorRegistry.register(name, check, iterfactory, override);
     },
 
     /** @id MochiKit.Iter.isIterable */
     isIterable: function(o) {
         return o != null &&
                (typeof(o.next) == "function" || typeof(o.iter) == "function");
     },
 
     /** @id MochiKit.Iter.iter */
     iter: function (iterable, /* optional */ sentinel) {
         var self = MochiKit.Iter;
         if (arguments.length == 2) {
             return self.takewhile(
                 function (a) { return a != sentinel; },
                 iterable
             );
         }
         if (typeof(iterable.next) == 'function') {
             return iterable;
         } else if (typeof(iterable.iter) == 'function') {
             return iterable.iter();
         /*
         }  else if (typeof(iterable.__iterator__) == 'function') {
             //
             // XXX: We can't support JavaScript 1.7 __iterator__ directly
             //      because of Object.prototype.__iterator__
             //
             return iterable.__iterator__();
         */
         }
 
         try {
             return self.iteratorRegistry.match(iterable);
         } catch (e) {
             var m = MochiKit.Base;
             if (e == m.NotFound) {
                 e = new TypeError(typeof(iterable) + ": " + m.repr(iterable) + " is not iterable");
             }
             throw e;
         }
     },
 
     /** @id MochiKit.Iter.count */
     count: function (n) {
         if (!n) {
             n = 0;
         }
         var m = MochiKit.Base;
         return {
             repr: function () { return "count(" + n + ")"; },
             toString: m.forwardCall("repr"),
             next: m.counter(n)
         };
     },
 
     /** @id MochiKit.Iter.cycle */
     cycle: function (p) {
         var self = MochiKit.Iter;
         var m = MochiKit.Base;
@@ -161,320 +161,318 @@ MochiKit.Base.update(MochiKit.Iter, {
         return {
             repr: function () { return "ifilter(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 while (true) {
                     var rval = seq.next();
                     if (pred(rval)) {
                         return rval;
                     }
                 }
                 // mozilla warnings aren't too bright
                 return undefined;
             }
         };
     },
 
     /** @id MochiKit.Iter.ifilterfalse */
     ifilterfalse: function (pred, seq) {
         var m = MochiKit.Base;
         seq = MochiKit.Iter.iter(seq);
         if (pred === null) {
             pred = m.operator.truth;
         }
         return {
             repr: function () { return "ifilterfalse(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 while (true) {
                     var rval = seq.next();
                     if (!pred(rval)) {
                         return rval;
                     }
                 }
                 // mozilla warnings aren't too bright
                 return undefined;
             }
         };
     },
 
     /** @id MochiKit.Iter.islice */
     islice: function (seq/*, [start,] stop[, step] */) {
         var self = MochiKit.Iter;
         var m = MochiKit.Base;
         seq = self.iter(seq);
         var start = 0;
         var stop = 0;
         var step = 1;
         var i = -1;
         if (arguments.length == 2) {
             stop = arguments[1];
         } else if (arguments.length == 3) {
             start = arguments[1];
             stop = arguments[2];
         } else {
             start = arguments[1];
             stop = arguments[2];
             step = arguments[3];
         }
         return {
             repr: function () {
                 return "islice(" + ["...", start, stop, step].join(", ") + ")";
             },
             toString: m.forwardCall("repr"),
             next: function () {
+                if (start >= stop) {
+                    throw self.StopIteration;
+                }
+
                 var rval;
                 while (i < start) {
                     rval = seq.next();
                     i++;
                 }
-                if (start >= stop) {
-                    throw self.StopIteration;
-                }
                 start += step;
                 return rval;
             }
         };
     },
 
     /** @id MochiKit.Iter.imap */
     imap: function (fun, p, q/*, ...*/) {
         var m = MochiKit.Base;
         var self = MochiKit.Iter;
         var iterables = m.map(self.iter, m.extend(null, arguments, 1));
         var map = m.map;
         var next = self.next;
         return {
             repr: function () { return "imap(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 return fun.apply(this, map(next, iterables));
             }
         };
     },
 
     /** @id MochiKit.Iter.applymap */
     applymap: function (fun, seq, self) {
         seq = MochiKit.Iter.iter(seq);
         var m = MochiKit.Base;
         return {
             repr: function () { return "applymap(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 return fun.apply(self, seq.next());
             }
         };
     },
 
     /** @id MochiKit.Iter.chain */
     chain: function (p, q/*, ...*/) {
         // dumb fast path
         var self = MochiKit.Iter;
         var m = MochiKit.Base;
         if (arguments.length == 1) {
             return self.iter(arguments[0]);
         }
         var argiter = m.map(self.iter, arguments);
         return {
             repr: function () { return "chain(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 while (argiter.length > 1) {
                     try {
-                        var result = argiter[0].next();
-                        return result;
+                        return argiter[0].next();
                     } catch (e) {
                         if (e != self.StopIteration) {
                             throw e;
                         }
                         argiter.shift();
-                        var result = argiter[0].next();
-                        return result;
                     }
                 }
                 if (argiter.length == 1) {
                     // optimize last element
                     var arg = argiter.shift();
                     this.next = m.bind("next", arg);
                     return this.next();
                 }
                 throw self.StopIteration;
             }
         };
     },
 
     /** @id MochiKit.Iter.takewhile */
     takewhile: function (pred, seq) {
         var self = MochiKit.Iter;
         seq = self.iter(seq);
         return {
             repr: function () { return "takewhile(...)"; },
             toString: MochiKit.Base.forwardCall("repr"),
             next: function () {
                 var rval = seq.next();
                 if (!pred(rval)) {
                     this.next = function () {
                         throw self.StopIteration;
                     };
                     this.next();
                 }
                 return rval;
             }
         };
     },
 
     /** @id MochiKit.Iter.dropwhile */
     dropwhile: function (pred, seq) {
         seq = MochiKit.Iter.iter(seq);
         var m = MochiKit.Base;
         var bind = m.bind;
         return {
             "repr": function () { return "dropwhile(...)"; },
             "toString": m.forwardCall("repr"),
             "next": function () {
                 while (true) {
                     var rval = seq.next();
                     if (!pred(rval)) {
                         break;
                     }
                 }
                 this.next = bind("next", seq);
                 return rval;
             }
         };
     },
 
     _tee: function (ident, sync, iterable) {
         sync.pos[ident] = -1;
         var m = MochiKit.Base;
         var listMin = m.listMin;
         return {
             repr: function () { return "tee(" + ident + ", ...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 var rval;
                 var i = sync.pos[ident];
 
                 if (i == sync.max) {
                     rval = iterable.next();
                     sync.deque.push(rval);
                     sync.max += 1;
                     sync.pos[ident] += 1;
                 } else {
                     rval = sync.deque[i - sync.min];
                     sync.pos[ident] += 1;
                     if (i == sync.min && listMin(sync.pos) != sync.min) {
                         sync.min += 1;
                         sync.deque.shift();
                     }
                 }
                 return rval;
             }
         };
     },
 
     /** @id MochiKit.Iter.tee */
     tee: function (iterable, n/* = 2 */) {
         var rval = [];
         var sync = {
             "pos": [],
             "deque": [],
             "max": -1,
             "min": -1
         };
         if (arguments.length == 1 || typeof(n) == "undefined" || n === null) {
             n = 2;
         }
         var self = MochiKit.Iter;
         iterable = self.iter(iterable);
         var _tee = self._tee;
         for (var i = 0; i < n; i++) {
             rval.push(_tee(i, sync, iterable));
         }
         return rval;
     },
 
     /** @id MochiKit.Iter.list */
     list: function (iterable) {
         // Fast-path for Array and Array-like
         var rval;
         if (iterable instanceof Array) {
             return iterable.slice();
         } 
         // this is necessary to avoid a Safari crash
         if (typeof(iterable) == "function" &&
                 !(iterable instanceof Function) &&
                 typeof(iterable.length) == 'number') {
             rval = [];
             for (var i = 0; i < iterable.length; i++) {
                 rval.push(iterable[i]);
             }
             return rval;
         }
 
         var self = MochiKit.Iter;
         iterable = self.iter(iterable);
-        var rval = [];
+        rval = [];
         var a_val;
         try {
             while (true) {
                 a_val = iterable.next();
                 rval.push(a_val);
             }
         } catch (e) {
             if (e != self.StopIteration) {
                 throw e;
             }
             return rval;
         }
         // mozilla warnings aren't too bright
         return undefined;
     },
 
 
     /** @id MochiKit.Iter.reduce */
     reduce: function (fn, iterable, /* optional */initial) {
         var i = 0;
         var x = initial;
         var self = MochiKit.Iter;
         iterable = self.iter(iterable);
         if (arguments.length < 3) {
             try {
                 x = iterable.next();
             } catch (e) {
                 if (e == self.StopIteration) {
                     e = new TypeError("reduce() of empty sequence with no initial value");
                 }
                 throw e;
             }
             i++;
         }
         try {
             while (true) {
                 x = fn(x, iterable.next());
             }
         } catch (e) {
             if (e != self.StopIteration) {
                 throw e;
             }
         }
         return x;
     },
 
     /** @id MochiKit.Iter.range */
     range: function (/* [start,] stop[, step] */) {
         var start = 0;
         var stop = 0;
         var step = 1;
         if (arguments.length == 1) {
             stop = arguments[0];
         } else if (arguments.length == 2) {
             start = arguments[0];
             stop = arguments[1];
         } else if (arguments.length == 3) {
             start = arguments[0];
             stop = arguments[1];
             step = arguments[2];
         } else {
             throw new TypeError("range() takes 1, 2, or 3 arguments!");
         }
         if (step === 0) {
diff --git a/frontend/gamma/js/MochiKit/Logging.js b/frontend/gamma/js/MochiKit/Logging.js
index f00996b..8b06e0b 100644
--- a/frontend/gamma/js/MochiKit/Logging.js
+++ b/frontend/gamma/js/MochiKit/Logging.js
@@ -1,75 +1,75 @@
 /***
 
 MochiKit.Logging 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Logging', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Logging', '1.5', ['Base']);
 
     /** @id MochiKit.Logging.LogMessage */
 MochiKit.Logging.LogMessage = function (num, level, info) {
     this.num = num;
     this.level = level;
     this.info = info;
     this.timestamp = new Date();
 };
 
 MochiKit.Logging.LogMessage.prototype = {
      /** @id MochiKit.Logging.LogMessage.prototype.repr */
     repr: function () {
         var m = MochiKit.Base;
         return 'LogMessage(' +
             m.map(
                 m.repr,
                 [this.num, this.level, this.info]
             ).join(', ') + ')';
     },
     /** @id MochiKit.Logging.LogMessage.prototype.toString */
     toString: MochiKit.Base.forwardCall("repr")
 };
 
 MochiKit.Base.update(MochiKit.Logging, {
     /** @id MochiKit.Logging.logLevelAtLeast */
     logLevelAtLeast: function (minLevel) {
         var self = MochiKit.Logging;
         if (typeof(minLevel) == 'string') {
             minLevel = self.LogLevel[minLevel];
         }
         return function (msg) {
             var msgLevel = msg.level;
             if (typeof(msgLevel) == 'string') {
                 msgLevel = self.LogLevel[msgLevel];
             }
             return msgLevel >= minLevel;
         };
     },
 
     /** @id MochiKit.Logging.isLogMessage */
     isLogMessage: function (/* ... */) {
         var LogMessage = MochiKit.Logging.LogMessage;
         for (var i = 0; i < arguments.length; i++) {
             if (!(arguments[i] instanceof LogMessage)) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.Logging.compareLogMessage */
     compareLogMessage: function (a, b) {
         return MochiKit.Base.compare([a.level, a.info], [b.level, b.info]);
     },
 
     /** @id MochiKit.Logging.alertListener */
     alertListener: function (msg) {
         alert(
             "num: " + msg.num +
             "\nlevel: " +  msg.level +
             "\ninfo: " + msg.info.join(" ")
         );
     }
 
@@ -126,129 +126,129 @@ MochiKit.Logging.Logger.prototype = {
     },
 
     /** @id MochiKit.Logging.Logger.prototype.addListener */
     addListener: function (ident, filter, listener) {
         if (typeof(filter) == 'string') {
             filter = MochiKit.Logging.logLevelAtLeast(filter);
         }
         var entry = [filter, listener];
         entry.ident = ident;
         this.listeners[ident] = entry;
     },
 
     /** @id MochiKit.Logging.Logger.prototype.removeListener */
     removeListener: function (ident) {
         delete this.listeners[ident];
     },
 
     /** @id MochiKit.Logging.Logger.prototype.baseLog */
     baseLog: function (level, message/*, ...*/) {
         if (typeof(level) == "number") {
             if (level >= MochiKit.Logging.LogLevel.FATAL) {
                 level = 'FATAL';
             } else if (level >= MochiKit.Logging.LogLevel.ERROR) {
                 level = 'ERROR';
             } else if (level >= MochiKit.Logging.LogLevel.WARNING) {
                 level = 'WARNING';
             } else if (level >= MochiKit.Logging.LogLevel.INFO) {
                 level = 'INFO';
             } else {
                 level = 'DEBUG';
             }
         }
         var msg = new MochiKit.Logging.LogMessage(
             this.counter,
             level,
             MochiKit.Base.extend(null, arguments, 1)
         );
         this._messages.push(msg);
         this.dispatchListeners(msg);
         if (this.useNativeConsole) {
             this.logToConsole(msg.level + ": " + msg.info.join(" "));
         }
         this.counter += 1;
         while (this.maxSize >= 0 && this._messages.length > this.maxSize) {
             this._messages.shift();
         }
     },
 
     /** @id MochiKit.Logging.Logger.prototype.getMessages */
     getMessages: function (howMany) {
         var firstMsg = 0;
         if (!(typeof(howMany) == 'undefined' || howMany === null)) {
             firstMsg = Math.max(0, this._messages.length - howMany);
         }
         return this._messages.slice(firstMsg);
     },
 
     /** @id MochiKit.Logging.Logger.prototype.getMessageText */
     getMessageText: function (howMany) {
         if (typeof(howMany) == 'undefined' || howMany === null) {
             howMany = 30;
         }
         var messages = this.getMessages(howMany);
         if (messages.length) {
-            var lst = map(function (m) {
+            var lst = MochiKit.Base.map(function (m) {
                 return '\n  [' + m.num + '] ' + m.level + ': ' + m.info.join(' ');
             }, messages);
             lst.unshift('LAST ' + messages.length + ' MESSAGES:');
             return lst.join('');
         }
         return '';
     },
 
     /** @id MochiKit.Logging.Logger.prototype.debuggingBookmarklet */
     debuggingBookmarklet: function (inline) {
         if (typeof(MochiKit.LoggingPane) == "undefined") {
             alert(this.getMessageText());
         } else {
             MochiKit.LoggingPane.createLoggingPane(inline || false);
         }
     }
 };
 
 MochiKit.Logging.__new__ = function () {
     this.LogLevel = {
         ERROR: 40,
         FATAL: 50,
         WARNING: 30,
         INFO: 20,
         DEBUG: 10
     };
 
     var m = MochiKit.Base;
     m.registerComparator("LogMessage",
         this.isLogMessage,
         this.compareLogMessage
     );
 
     var partial = m.partial;
 
     var Logger = this.Logger;
     var baseLog = Logger.prototype.baseLog;
     m.update(this.Logger.prototype, {
         debug: partial(baseLog, 'DEBUG'),
         log: partial(baseLog, 'INFO'),
         error: partial(baseLog, 'ERROR'),
         fatal: partial(baseLog, 'FATAL'),
         warning: partial(baseLog, 'WARNING')
     });
 
     // indirectly find logger so it can be replaced
     var self = this;
     var connectLog = function (name) {
         return function () {
             self.logger[name].apply(self.logger, arguments);
         };
     };
 
     /** @id MochiKit.Logging.log */
     this.log = connectLog('log');
     /** @id MochiKit.Logging.logError */
     this.logError = connectLog('error');
     /** @id MochiKit.Logging.logDebug */
     this.logDebug = connectLog('debug');
     /** @id MochiKit.Logging.logFatal */
     this.logFatal = connectLog('fatal');
     /** @id MochiKit.Logging.logWarning */
     this.logWarning = connectLog('warning');
     this.logger = new Logger();
diff --git a/frontend/gamma/js/MochiKit/LoggingPane.js b/frontend/gamma/js/MochiKit/LoggingPane.js
index c960c21..b7ea120 100644
--- a/frontend/gamma/js/MochiKit/LoggingPane.js
+++ b/frontend/gamma/js/MochiKit/LoggingPane.js
@@ -1,291 +1,294 @@
 /***
 
 MochiKit.LoggingPane 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('LoggingPane', '1.5', ['Base', 'Logging']);
+MochiKit.Base.module(MochiKit, 'LoggingPane', '1.5', ['Base', 'Logging']);
 
 /** @id MochiKit.LoggingPane.createLoggingPane */
 MochiKit.LoggingPane.createLoggingPane = function (inline/* = false */) {
     var m = MochiKit.LoggingPane;
     inline = !(!inline);
     if (m._loggingPane && m._loggingPane.inline != inline) {
         m._loggingPane.closePane();
         m._loggingPane = null;
     }
     if (!m._loggingPane || m._loggingPane.closed) {
         m._loggingPane = new m.LoggingPane(inline, MochiKit.Logging.logger);
     }
     return m._loggingPane;
 };
 
-/** @id MochiKit.LoggingPane.LoggingPane */
+/**
+ * @id MochiKit.LoggingPane.LoggingPane
+ * @constructor
+ */
 MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = MochiKit.Logging.logger */) {
 
     /* Use a div if inline, pop up a window if not */
     /* Create the elements */
     if (typeof(logger) == "undefined" || logger === null) {
         logger = MochiKit.Logging.logger;
     }
     this.logger = logger;
     var update = MochiKit.Base.update;
     var updatetree = MochiKit.Base.updatetree;
     var bind = MochiKit.Base.bind;
     var clone = MochiKit.Base.clone;
     var win = window;
     var uid = "_MochiKit_LoggingPane";
     if (typeof(MochiKit.DOM) != "undefined") {
         win = MochiKit.DOM.currentWindow();
     }
     if (!inline) {
         // name the popup with the base URL for uniqueness
         var url = win.location.href.split("?")[0].replace(/[#:\/.><&%-]/g, "_");
         var name = uid + "_" + url;
         var nwin = win.open("", name, "dependent,resizable,height=200");
         if (!nwin) {
             alert("Not able to open debugging window due to pop-up blocking.");
             return undefined;
         }
         nwin.document.write(
             '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" '
             + '"http://www.w3.org/TR/html4/loose.dtd">'
             + '<html><head><title>[MochiKit.LoggingPane]</title></head>'
             + '<body></body></html>'
         );
         nwin.document.close();
         nwin.document.title += ' ' + win.document.title;
         win = nwin;
     }
     var doc = win.document;
     this.doc = doc;
 
     // Connect to the debug pane if it already exists (i.e. in a window orphaned by the page being refreshed)
     var debugPane = doc.getElementById(uid);
     var existing_pane = !!debugPane;
     if (debugPane && typeof(debugPane.loggingPane) != "undefined") {
         debugPane.loggingPane.logger = this.logger;
         debugPane.loggingPane.buildAndApplyFilter();
         return debugPane.loggingPane;
     }
 
     if (existing_pane) {
         // clear any existing contents
         var child;
         while ((child = debugPane.firstChild)) {
             debugPane.removeChild(child);
         }
     } else {
         debugPane = doc.createElement("div");
         debugPane.id = uid;
     }
     debugPane.loggingPane = this;
     var levelFilterField = doc.createElement("input");
     var infoFilterField = doc.createElement("input");
     var filterButton = doc.createElement("button");
     var loadButton = doc.createElement("button");
     var clearButton = doc.createElement("button");
     var closeButton = doc.createElement("button");
     var logPaneArea = doc.createElement("div");
     var logPane = doc.createElement("div");
 
     /* Set up the functions */
     var listenerId = uid + "_Listener";
     this.colorTable = clone(this.colorTable);
     var messages = [];
     var messageFilter = null;
 
     /** @id MochiKit.LoggingPane.messageLevel */
     var messageLevel = function (msg) {
         var level = msg.level;
         if (typeof(level) == "number") {
             level = MochiKit.Logging.LogLevel[level];
         }
         return level;
     };
 
     /** @id MochiKit.LoggingPane.messageText */
     var messageText = function (msg) {
         return msg.info.join(" ");
     };
 
     /** @id MochiKit.LoggingPane.addMessageText */
     var addMessageText = bind(function (msg) {
         var level = messageLevel(msg);
         var text = messageText(msg);
         var c = this.colorTable[level];
         var p = doc.createElement("span");
         p.className = "MochiKit-LogMessage MochiKit-LogLevel-" + level;
         p.style.cssText = "margin: 0px; white-space: -moz-pre-wrap; white-space: -o-pre-wrap; white-space: pre-wrap; white-space: pre-line; word-wrap: break-word; wrap-option: emergency; color: " + c;
         p.appendChild(doc.createTextNode(level + ": " + text));
         logPane.appendChild(p);
         logPane.appendChild(doc.createElement("br"));
         if (logPaneArea.offsetHeight > logPaneArea.scrollHeight) {
             logPaneArea.scrollTop = 0;
         } else {
             logPaneArea.scrollTop = logPaneArea.scrollHeight;
         }
     }, this);
 
     /** @id MochiKit.LoggingPane.addMessage */
     var addMessage = function (msg) {
         messages[messages.length] = msg;
         addMessageText(msg);
     };
 
     /** @id MochiKit.LoggingPane.buildMessageFilter */
     var buildMessageFilter = function () {
         var levelre, infore;
         try {
             /* Catch any exceptions that might arise due to invalid regexes */
             levelre = new RegExp(levelFilterField.value);
             infore = new RegExp(infoFilterField.value);
         } catch(e) {
             /* If there was an error with the regexes, do no filtering */
-            logDebug("Error in filter regex: " + e.message);
+            MochiKit.Logging.logDebug("Error in filter regex: " + e.message);
             return null;
         }
 
         return function (msg) {
             return (
                 levelre.test(messageLevel(msg)) &&
                 infore.test(messageText(msg))
             );
         };
     };
 
     /** @id MochiKit.LoggingPane.clearMessagePane */
     var clearMessagePane = function () {
         while (logPane.firstChild) {
             logPane.removeChild(logPane.firstChild);
         }
     };
 
     /** @id MochiKit.LoggingPane.clearMessages */
     var clearMessages = function () {
         messages = [];
         clearMessagePane();
     };
 
     /** @id MochiKit.LoggingPane.closePane */
     var closePane = bind(function () {
         if (this.closed) {
             return;
         }
         this.closed = true;
         if (MochiKit.LoggingPane._loggingPane == this) {
             MochiKit.LoggingPane._loggingPane = null;
         }
         this.logger.removeListener(listenerId);
         try {
             try {
               debugPane.loggingPane = null;
-            } catch(e) { logFatal("Bookmarklet was closed incorrectly."); }
+            } catch(e) { MochiKit.Logging.logFatal("Bookmarklet was closed incorrectly."); }
             if (inline) {
                 debugPane.parentNode.removeChild(debugPane);
             } else {
                 this.win.close();
             }
         } catch(e) {}
     }, this);
 
     /** @id MochiKit.LoggingPane.filterMessages */
     var filterMessages = function () {
         clearMessagePane();
 
         for (var i = 0; i < messages.length; i++) {
             var msg = messages[i];
             if (messageFilter === null || messageFilter(msg)) {
                 addMessageText(msg);
             }
         }
     };
 
     this.buildAndApplyFilter = function () {
         messageFilter = buildMessageFilter();
 
         filterMessages();
 
         this.logger.removeListener(listenerId);
         this.logger.addListener(listenerId, messageFilter, addMessage);
     };
 
 
     /** @id MochiKit.LoggingPane.loadMessages */
     var loadMessages = bind(function () {
         messages = this.logger.getMessages();
         filterMessages();
     }, this);
 
     /** @id MochiKit.LoggingPane.filterOnEnter */
     var filterOnEnter = bind(function (event) {
         event = event || window.event;
-        key = event.which || event.keyCode;
+        var key = event.which || event.keyCode;
         if (key == 13) {
             this.buildAndApplyFilter();
         }
     }, this);
 
     /* Create the debug pane */
     var style = "display: block; z-index: 1000; left: 0px; bottom: 0px; position: fixed; width: 100%; background-color: white; font: " + this.logFont;
     if (inline) {
         style += "; height: 10em; border-top: 2px solid black";
     } else {
         style += "; height: 100%;";
     }
     debugPane.style.cssText = style;
 
     if (!existing_pane) {
         doc.body.appendChild(debugPane);
     }
 
     /* Create the filter fields */
     style = {"cssText": "width: 33%; display: inline; font: " + this.logFont};
 
     updatetree(levelFilterField, {
         "value": "FATAL|ERROR|WARNING|INFO|DEBUG",
         "onkeypress": filterOnEnter,
         "style": style
     });
     debugPane.appendChild(levelFilterField);
 
     updatetree(infoFilterField, {
         "value": ".*",
         "onkeypress": filterOnEnter,
         "style": style
     });
     debugPane.appendChild(infoFilterField);
 
     /* Create the buttons */
     style = "width: 8%; display:inline; font: " + this.logFont;
 
     filterButton.appendChild(doc.createTextNode("Filter"));
     filterButton.onclick = bind("buildAndApplyFilter", this);
     filterButton.style.cssText = style;
     debugPane.appendChild(filterButton);
 
     loadButton.appendChild(doc.createTextNode("Load"));
     loadButton.onclick = loadMessages;
     loadButton.style.cssText = style;
     debugPane.appendChild(loadButton);
 
     clearButton.appendChild(doc.createTextNode("Clear"));
     clearButton.onclick = clearMessages;
     clearButton.style.cssText = style;
     debugPane.appendChild(clearButton);
 
     closeButton.appendChild(doc.createTextNode("Close"));
     closeButton.onclick = closePane;
     closeButton.style.cssText = style;
     debugPane.appendChild(closeButton);
 
     /* Create the logging pane */
     logPaneArea.style.cssText = "overflow: auto; width: 100%";
     logPane.style.cssText = "width: 100%; height: " + (inline ? "8em" : "100%");
 
     logPaneArea.appendChild(logPane);
     debugPane.appendChild(logPaneArea);
diff --git a/frontend/gamma/js/MochiKit/MochiKit.js b/frontend/gamma/js/MochiKit/MochiKit.js
index 8e5be68..511e075 100644
--- a/frontend/gamma/js/MochiKit/MochiKit.js
+++ b/frontend/gamma/js/MochiKit/MochiKit.js
@@ -1,85 +1,82 @@
 /***
 
 MochiKit.MochiKit 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-if (typeof(MochiKit) == 'undefined') {
-    MochiKit = {};
-}
+var MochiKit = MochiKit || {};
 
-if (typeof(MochiKit.MochiKit) == 'undefined') {
-    /** @id MochiKit.MochiKit */
-    MochiKit.MochiKit = {};
-}
+/** @id MochiKit.MochiKit */
+MochiKit.MochiKit = MochiKit.MochiKit || {};
 
 MochiKit.MochiKit.NAME = "MochiKit.MochiKit";
 MochiKit.MochiKit.VERSION = "1.5";
+MochiKit.MochiKit.__export__ = false;
 MochiKit.MochiKit.__repr__ = function () {
     return "[" + this.NAME + " " + this.VERSION + "]";
 };
 
 /** @id MochiKit.MochiKit.toString */
 MochiKit.MochiKit.toString = function () {
     return this.__repr__();
 };
 
 /** @id MochiKit.MochiKit.SUBMODULES */
 MochiKit.MochiKit.SUBMODULES = [
     "Base",
     "Iter",
     "Logging",
     "DateTime",
     "Format",
     "Text",
     "Async",
     "DOM",
     "Selector",
     "Style",
     "LoggingPane",
     "Color",
     "Signal",
     "Position",
     "Visual",
     "DragAndDrop",
     "Sortable"
 ];
 
 (function () {
     if (typeof(document) == "undefined") {
         return;
     }
     var scripts = document.getElementsByTagName("script");
     var kXHTMLNSURI = "http://www.w3.org/1999/xhtml";
     var kSVGNSURI = "http://www.w3.org/2000/svg";
     var kXLINKNSURI = "http://www.w3.org/1999/xlink";
     var kXULNSURI = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
     var base = null;
     var baseElem = null;
     var allScripts = {};
     var i;
     var src;
     for (i = 0; i < scripts.length; i++) {
         src = null;
         switch (scripts[i].namespaceURI) {
             case kSVGNSURI:
                 src = scripts[i].getAttributeNS(kXLINKNSURI, "href");
                 break;
             /*
             case null: // HTML
             case '': // HTML
             case kXHTMLNSURI:
             case kXULNSURI:
             */
             default:
                 src = scripts[i].getAttribute("src");
                 break;
         }
         if (!src) {
             continue;
         }
         allScripts[src] = true;
diff --git a/frontend/gamma/js/MochiKit/MockDOM.js b/frontend/gamma/js/MochiKit/MockDOM.js
index abdb54a..7e6d60b 100644
--- a/frontend/gamma/js/MochiKit/MockDOM.js
+++ b/frontend/gamma/js/MochiKit/MockDOM.js
@@ -1,84 +1,81 @@
 /***
 
 MochiKit.MockDOM 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-if (typeof(MochiKit) == "undefined") {
-    MochiKit = {};
-}
+var MochiKit = MochiKit || {};
 
-if (typeof(MochiKit.MockDOM) == "undefined") {
-    MochiKit.MockDOM = {};
-}
+MochiKit.MockDOM = MochiKit.MockDOM || {};
 
 MochiKit.MockDOM.NAME = "MochiKit.MockDOM";
 MochiKit.MockDOM.VERSION = "1.5";
+MochiKit.MockDOM.__export__ = false;
 
 MochiKit.MockDOM.__repr__ = function () {
     return "[" + this.NAME + " " + this.VERSION + "]";
 };
 
 /** @id MochiKit.MockDOM.toString */
 MochiKit.MockDOM.toString = function () {
     return this.__repr__();
 };
 
 /** @id MochiKit.MockDOM.createDocument */
 MochiKit.MockDOM.createDocument = function () {
     var doc = new MochiKit.MockDOM.MockElement("DOCUMENT");
     doc.body = doc.createElement("BODY");
     doc.appendChild(doc.body);
     return doc;
 };
 
 /** @id MochiKit.MockDOM.MockElement */
 MochiKit.MockDOM.MockElement = function (name, data, ownerDocument) {
     this.tagName = this.nodeName = name.toUpperCase();
     this.ownerDocument = ownerDocument || null;
     if (name == "DOCUMENT") {
         this.nodeType = 9;
         this.childNodes = [];
     } else if (typeof(data) == "string") {
         this.nodeValue = data;
         this.nodeType = 3;
     } else {
         this.nodeType = 1;
         this.childNodes = [];
     }
     if (name.substring(0, 1) == "<") {
         var nameattr = name.substring(
             name.indexOf('"') + 1, name.lastIndexOf('"'));
         name = name.substring(1, name.indexOf(" "));
         this.tagName = this.nodeName = name.toUpperCase();
         this.setAttribute("name", nameattr);
     }
 };
 
 MochiKit.MockDOM.MockElement.prototype = {
     /** @id MochiKit.MockDOM.MockElement.prototype.createElement */
     createElement: function (tagName) {
         return new MochiKit.MockDOM.MockElement(tagName, null, this.nodeType == 9 ? this : this.ownerDocument);
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.createTextNode */
     createTextNode: function (text) {
         return new MochiKit.MockDOM.MockElement("text", text, this.nodeType == 9 ? this : this.ownerDocument);
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.setAttribute */
     setAttribute: function (name, value) {
         this[name] = value;
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.getAttribute */
     getAttribute: function (name) {
         return this[name];
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.appendChild */
     appendChild: function (child) {
         this.childNodes.push(child);
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.toString */
     toString: function () {
diff --git a/frontend/gamma/js/MochiKit/Position.js b/frontend/gamma/js/MochiKit/Position.js
index 6bc5b39..2680507 100644
--- a/frontend/gamma/js/MochiKit/Position.js
+++ b/frontend/gamma/js/MochiKit/Position.js
@@ -1,75 +1,75 @@
 /***
 
 MochiKit.Position 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005-2006 Bob Ippolito and others.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Position', '1.5', ['Base', 'DOM', 'Style']);
+MochiKit.Base.module(MochiKit, 'Position', '1.5', ['Base', 'DOM', 'Style']);
 
 MochiKit.Base.update(MochiKit.Position, {
     // Don't export from this module
     __export__: false,
 
     // set to true if needed, warning: firefox performance problems
     // NOT neeeded for page scrolling, only if draggable contained in
     // scrollable elements
     includeScrollOffsets: false,
 
     /** @id MochiKit.Position.prepare */
     prepare: function () {
         var deltaX =  window.pageXOffset
                    || document.documentElement.scrollLeft
                    || document.body.scrollLeft
                    || 0;
         var deltaY =  window.pageYOffset
                    || document.documentElement.scrollTop
                    || document.body.scrollTop
                    || 0;
         this.windowOffset = new MochiKit.Style.Coordinates(deltaX, deltaY);
     },
 
     /** @id MochiKit.Position.cumulativeOffset */
     cumulativeOffset: function (element) {
         var valueT = 0;
         var valueL = 0;
         do {
             valueT += element.offsetTop  || 0;
             valueL += element.offsetLeft || 0;
             element = element.offsetParent;
         } while (element);
         return new MochiKit.Style.Coordinates(valueL, valueT);
     },
 
     /** @id MochiKit.Position.realOffset */
     realOffset: function (element) {
         var valueT = 0;
         var valueL = 0;
         do {
             valueT += element.scrollTop  || 0;
             valueL += element.scrollLeft || 0;
             element = element.parentNode;
         } while (element);
         return new MochiKit.Style.Coordinates(valueL, valueT);
     },
 
     /** @id MochiKit.Position.within */
     within: function (element, x, y) {
         if (this.includeScrollOffsets) {
             return this.withinIncludingScrolloffsets(element, x, y);
         }
         this.xcomp = x;
         this.ycomp = y;
         this.offset = this.cumulativeOffset(element);
         if (element.style.position == "fixed") {
             this.offset.x += this.windowOffset.x;
             this.offset.y += this.windowOffset.y;
         }
 
         return (y >= this.offset.y &&
                 y <  this.offset.y + element.offsetHeight &&
                 x >= this.offset.x &&
                 x <  this.offset.x + element.offsetWidth);
diff --git a/frontend/gamma/js/MochiKit/Selector.js b/frontend/gamma/js/MochiKit/Selector.js
index 6aec892..3187fe9 100644
--- a/frontend/gamma/js/MochiKit/Selector.js
+++ b/frontend/gamma/js/MochiKit/Selector.js
@@ -1,244 +1,244 @@
 /***
 
 MochiKit.Selector 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito and others.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Selector', '1.5', ['Base', 'DOM', 'Iter']);
+MochiKit.Base.module(MochiKit, 'Selector', '1.5', ['Base', 'DOM', 'Iter']);
 
 MochiKit.Selector.Selector = function (expression) {
     this.params = {classNames: [], pseudoClassNames: []};
     this.expression = expression.toString().replace(/(^\s+|\s+$)/g, '');
     this.parseExpression();
     this.compileMatcher();
 };
 
 MochiKit.Selector.Selector.prototype = {
     /***
 
     Selector class: convenient object to make CSS selections.
 
     ***/
     __class__: MochiKit.Selector.Selector,
 
     /** @id MochiKit.Selector.Selector.prototype.parseExpression */
     parseExpression: function () {
         function abort(message) {
             throw 'Parse error in selector: ' + message;
         }
 
         if (this.expression == '')  {
             abort('empty expression');
         }
 
         var repr = MochiKit.Base.repr;
         var params = this.params;
         var expr = this.expression;
         var match, modifier, clause, rest;
         while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!^$*]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
             params.attributes = params.attributes || [];
             params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
             expr = match[1];
         }
 
         if (expr == '*') {
             return this.params.wildcard = true;
         }
 
         while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+(?:\([^)]*\))?)(.*)/i)) {
             modifier = match[1];
             clause = match[2];
             rest = match[3];
             switch (modifier) {
                 case '#':
                     params.id = clause;
                     break;
                 case '.':
                     params.classNames.push(clause);
                     break;
                 case ':':
                     params.pseudoClassNames.push(clause);
                     break;
                 case '':
                 case undefined:
                     params.tagName = clause.toUpperCase();
                     break;
                 default:
                     abort(repr(expr));
             }
             expr = rest;
         }
 
         if (expr.length > 0) {
             abort(repr(expr));
         }
     },
 
     /** @id MochiKit.Selector.Selector.prototype.buildMatchExpression */
     buildMatchExpression: function () {
         var repr = MochiKit.Base.repr;
         var params = this.params;
         var conditions = [];
         var clause, i;
 
         function childElements(element) {
             return "MochiKit.Base.filter(function (node) { return node.nodeType == 1; }, " + element + ".childNodes)";
         }
 
         if (params.wildcard) {
             conditions.push('true');
         }
         if (clause = params.id) {
             conditions.push('element.id == ' + repr(clause));
         }
         if (clause = params.tagName) {
             conditions.push('element.tagName.toUpperCase() == ' + repr(clause));
         }
         if ((clause = params.classNames).length > 0) {
             for (i = 0; i < clause.length; i++) {
                 conditions.push('MochiKit.DOM.hasElementClass(element, ' + repr(clause[i]) + ')');
             }
         }
         if ((clause = params.pseudoClassNames).length > 0) {
             for (i = 0; i < clause.length; i++) {
                 var match = clause[i].match(/^([^(]+)(?:\((.*)\))?$/);
                 var pseudoClass = match[1];
                 var pseudoClassArgument = match[2];
                 switch (pseudoClass) {
                     case 'root':
                         conditions.push('element.nodeType == 9 || element === element.ownerDocument.documentElement'); break;
                     case 'nth-child':
                     case 'nth-last-child':
                     case 'nth-of-type':
                     case 'nth-last-of-type':
                         match = pseudoClassArgument.match(/^((?:(\d+)n\+)?(\d+)|odd|even)$/);
                         if (!match) {
                             throw "Invalid argument to pseudo element nth-child: " + pseudoClassArgument;
                         }
                         var a, b;
                         if (match[0] == 'odd') {
                             a = 2;
                             b = 1;
                         } else if (match[0] == 'even') {
                             a = 2;
                             b = 0;
                         } else {
-                            a = match[2] && parseInt(match) || null;
-                            b = parseInt(match[3]);
+                            a = match[2] && parseInt(match, 10) || null;
+                            b = parseInt(match[3], 10);
                         }
                         conditions.push('this.nthChild(element,' + a + ',' + b
                                         + ',' + !!pseudoClass.match('^nth-last')    // Reverse
                                         + ',' + !!pseudoClass.match('of-type$')     // Restrict to same tagName
                                         + ')');
                         break;
                     case 'first-child':
                         conditions.push('this.nthChild(element, null, 1)');
                         break;
                     case 'last-child':
                         conditions.push('this.nthChild(element, null, 1, true)');
                         break;
                     case 'first-of-type':
                         conditions.push('this.nthChild(element, null, 1, false, true)');
                         break;
                     case 'last-of-type':
                         conditions.push('this.nthChild(element, null, 1, true, true)');
                         break;
                     case 'only-child':
                         conditions.push(childElements('element.parentNode') + '.length == 1');
                         break;
                     case 'only-of-type':
                         conditions.push('MochiKit.Base.filter(function (node) { return node.tagName == element.tagName; }, ' + childElements('element.parentNode') + ').length == 1');
                         break;
                     case 'empty':
                         conditions.push('element.childNodes.length == 0');
                         break;
                     case 'enabled':
                         conditions.push('(this.isUIElement(element) && element.disabled === false)');
                         break;
                     case 'disabled':
                         conditions.push('(this.isUIElement(element) && element.disabled === true)');
                         break;
                     case 'checked':
                         conditions.push('(this.isUIElement(element) && element.checked === true)');
                         break;
                     case 'not':
                         var subselector = new MochiKit.Selector.Selector(pseudoClassArgument);
-                        conditions.push('!( ' + subselector.buildMatchExpression() + ')')
+                        conditions.push('!( ' + subselector.buildMatchExpression() + ')');
                         break;
                 }
             }
         }
         if (clause = params.attributes) {
             MochiKit.Base.map(function (attribute) {
                 var value = 'MochiKit.DOM.getNodeAttribute(element, ' + repr(attribute.name) + ')';
                 var splitValueBy = function (delimiter) {
                     return value + '.split(' + repr(delimiter) + ')';
-                }
+                };
                 conditions.push(value + ' != null');
                 switch (attribute.operator) {
                     case '=':
                         conditions.push(value + ' == ' + repr(attribute.value));
                         break;
                     case '~=':
                         conditions.push('MochiKit.Base.findValue(' + splitValueBy(' ') + ', ' + repr(attribute.value) + ') > -1');
                         break;
                     case '^=':
                         conditions.push(value + '.substring(0, ' + attribute.value.length + ') == ' + repr(attribute.value));
                         break;
                     case '$=':
                         conditions.push(value + '.substring(' + value + '.length - ' + attribute.value.length + ') == ' + repr(attribute.value));
                         break;
                     case '*=':
                         conditions.push(value + '.match(' + repr(attribute.value) + ')');
                         break;
                     case '|=':
                         conditions.push(splitValueBy('-') + '[0].toUpperCase() == ' + repr(attribute.value.toUpperCase()));
                         break;
                     case '!=':
                         conditions.push(value + ' != ' + repr(attribute.value));
                         break;
                     case '':
                     case undefined:
                         // Condition already added above
                         break;
                     default:
                         throw 'Unknown operator ' + attribute.operator + ' in selector';
                 }
             }, clause);
         }
 
         return conditions.join(' && ');
     },
 
     /** @id MochiKit.Selector.Selector.prototype.compileMatcher */
     compileMatcher: function () {
         var code = 'return (!element.tagName) ? false : ' +
                    this.buildMatchExpression() + ';';
         this.match = new Function('element', code);
     },
 
     /** @id MochiKit.Selector.Selector.prototype.nthChild */
     nthChild: function (element, a, b, reverse, sametag){
         var siblings = MochiKit.Base.filter(function (node) {
             return node.nodeType == 1;
         }, element.parentNode.childNodes);
         if (sametag) {
             siblings = MochiKit.Base.filter(function (node) {
                 return node.tagName == element.tagName;
             }, siblings);
         }
         if (reverse) {
             siblings = MochiKit.Iter.reversed(siblings);
         }
         if (a) {
             var actualIndex = MochiKit.Base.findIdentical(siblings, element);
             return ((actualIndex + 1 - b) / a) % 1 == 0;
         } else {
             return b == MochiKit.Base.findIdentical(siblings, element) + 1;
         }
     },
 
@@ -291,97 +291,103 @@ MochiKit.Selector.Selector.prototype = {
             }
             return node;
         }
 
         if (axis == "") {
             scope = (scope || MochiKit.DOM.currentDocument()).getElementsByTagName(this.params.tagName || '*');
         } else if (axis == ">") {
             if (!scope) {
                 throw "> combinator not allowed without preceeding expression";
             }
             scope = MochiKit.Base.filter(function (node) {
                 return node.nodeType == 1;
             }, scope.childNodes);
         } else if (axis == "+") {
             if (!scope) {
                 throw "+ combinator not allowed without preceeding expression";
             }
             scope = nextSiblingElement(scope) && [nextSiblingElement(scope)];
         } else if (axis == "~") {
             if (!scope) {
                 throw "~ combinator not allowed without preceeding expression";
             }
             var newscope = [];
             while (nextSiblingElement(scope)) {
                 scope = nextSiblingElement(scope);
                 newscope.push(scope);
             }
             scope = newscope;
         }
 
         if (!scope) {
             return [];
         }
 
         var results = MochiKit.Base.filter(MochiKit.Base.bind(function (scopeElt) {
             return this.match(scopeElt);
         }, this), scope);
 
         return results;
     },
 
     /** @id MochiKit.Selector.Selector.prototype.repr */
     repr: function () {
         return 'Selector(' + this.expression + ')';
     },
 
     toString: MochiKit.Base.forwardCall("repr")
 };
 
 MochiKit.Base.update(MochiKit.Selector, {
 
     /** @id MochiKit.Selector.findChildElements */
     findChildElements: function (element, expressions) {
         element = MochiKit.DOM.getElement(element);
         var uniq = function(arr) {
             var res = [];
             for (var i = 0; i < arr.length; i++) {
                 if (MochiKit.Base.findIdentical(res, arr[i]) < 0) {
                     res.push(arr[i]);
                 }
             }
             return res;
         };
         return MochiKit.Base.flattenArray(MochiKit.Base.map(function (expression) {
+            try {
+                var res = element.querySelectorAll(expression);
+                return Array.prototype.slice.call(res, 0);
+            } catch (ignore) {
+                // No querySelectorAll or extended expression syntax used
+            }
             var nextScope = "";
             var reducer = function (results, expr) {
                 var match = expr.match(/^[>+~]$/);
                 if (match) {
                     nextScope = match[0];
                     return results;
                 } else {
                     var selector = new MochiKit.Selector.Selector(expr);
                     var elements = MochiKit.Iter.reduce(function (elements, result) {
                         return MochiKit.Base.extend(elements, selector.findElements(result || element, nextScope));
                     }, results, []);
                     nextScope = "";
                     return elements;
                 }
             };
             var exprs = expression.replace(/(^\s+|\s+$)/g, '').split(/\s+/);
             return uniq(MochiKit.Iter.reduce(reducer, exprs, [null]));
         }, expressions));
     },
 
     findDocElements: function () {
         return MochiKit.Selector.findChildElements(MochiKit.DOM.currentDocument(), arguments);
     },
 
     __new__: function () {
         this.$$ = this.findDocElements;
         MochiKit.Base.nameFunctions(this);
     }
 });
 
 MochiKit.Selector.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.Selector);
diff --git a/frontend/gamma/js/MochiKit/Signal.js b/frontend/gamma/js/MochiKit/Signal.js
index 7df5619..11590c1 100644
--- a/frontend/gamma/js/MochiKit/Signal.js
+++ b/frontend/gamma/js/MochiKit/Signal.js
@@ -1,75 +1,75 @@
 /***
 
 MochiKit.Signal 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2006 Jonathan Gardner, Beau Hartshorne, Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Signal', '1.5', ['Base', 'DOM', 'Style']);
+MochiKit.Base.module(MochiKit, 'Signal', '1.5', ['Base', 'DOM']);
 
 MochiKit.Signal._observers = [];
 
 /** @id MochiKit.Signal.Event */
 MochiKit.Signal.Event = function (src, e) {
     this._event = e || window.event;
     this._src = src;
 };
 MochiKit.Signal.Event.__export__ = false;
 
 MochiKit.Base.update(MochiKit.Signal.Event.prototype, {
 
     __repr__: function () {
         var repr = MochiKit.Base.repr;
         var str = '{event(): ' + repr(this.event()) +
             ', src(): ' + repr(this.src()) +
             ', type(): ' + repr(this.type()) +
             ', target(): ' + repr(this.target());
 
         if (this.type() &&
             this.type().indexOf('key') === 0 ||
             this.type().indexOf('mouse') === 0 ||
             this.type().indexOf('click') != -1 ||
             this.type() == 'contextmenu') {
             str += ', modifier(): ' + '{alt: ' + repr(this.modifier().alt) +
             ', ctrl: ' + repr(this.modifier().ctrl) +
             ', meta: ' + repr(this.modifier().meta) +
             ', shift: ' + repr(this.modifier().shift) +
             ', any: ' + repr(this.modifier().any) + '}';
         }
 
         if (this.type() && this.type().indexOf('key') === 0) {
             str += ', key(): {code: ' + repr(this.key().code) +
                 ', string: ' + repr(this.key().string) + '}';
         }
 
         if (this.type() && (
             this.type().indexOf('mouse') === 0 ||
             this.type().indexOf('click') != -1 ||
             this.type() == 'contextmenu')) {
 
             str += ', mouse(): {page: ' + repr(this.mouse().page) +
                 ', client: ' + repr(this.mouse().client);
 
             if (this.type() != 'mousemove' && this.type() != 'mousewheel') {
                 str += ', button: {left: ' + repr(this.mouse().button.left) +
                     ', middle: ' + repr(this.mouse().button.middle) +
                     ', right: ' + repr(this.mouse().button.right) + '}';
             }
             if (this.type() == 'mousewheel') {
                 str += ', wheel: ' + repr(this.mouse().wheel);
             }
             str += '}';
         }
         if (this.type() == 'mouseover' || this.type() == 'mouseout' || 
             this.type() == 'mouseenter' || this.type() == 'mouseleave') {
             str += ', relatedTarget(): ' + repr(this.relatedTarget());
         }
         str += '}';
         return str;
     },
 
      /** @id MochiKit.Signal.Event.prototype.toString */
     toString: function () {
@@ -205,200 +205,201 @@ MochiKit.Base.update(MochiKit.Signal.Event.prototype, {
                 a       kp      97          97
                 shift+a ku,kd   65          65
                 shift+a kp      65          65
                 1       ku,kd   49          49
                 1       kp      49          49
                 shift+1 ku,kd   33          49
                 shift+1 kp      33          33
 
             */
 
             /* look for special keys here */
             if (this.type() == 'keydown' || this.type() == 'keyup') {
                 k.code = this._event.keyCode;
                 k.string = (MochiKit.Signal._specialKeys[k.code] ||
                     'KEY_UNKNOWN');
                 this._key = k;
                 return k;
 
             /* look for characters here */
             } else if (this.type() == 'keypress') {
 
                 /*
 
                     Special key behavior:
 
                     IE: does not fire keypress events for special keys
                     FF: sets charCode to 0, and sets the correct keyCode
                     Safari: sets keyCode and charCode to something stupid
 
                 */
 
                 k.code = 0;
                 k.string = '';
 
                 if (typeof(this._event.charCode) != 'undefined' &&
                     this._event.charCode !== 0 &&
                     !MochiKit.Signal._specialMacKeys[this._event.charCode]) {
                     k.code = this._event.charCode;
                     k.string = String.fromCharCode(k.code);
                 } else if (this._event.keyCode &&
                     typeof(this._event.charCode) == 'undefined') { // IE
                     k.code = this._event.keyCode;
                     k.string = String.fromCharCode(k.code);
                 }
 
                 this._key = k;
                 return k;
             }
         }
         return undefined;
     },
 
     _mouse: null,
     /** @id MochiKit.Signal.Event.prototype.mouse */
     mouse: function () {
         if (this._mouse !== null) {
             return this._mouse;
         }
 
         var m = {};
         var e = this._event;
 
         if (this.type() && (
             this.type().indexOf('mouse') === 0 ||
+            this.type().indexOf('drag') === 0 ||
             this.type().indexOf('click') != -1 ||
             this.type() == 'contextmenu')) {
 
-            m.client = new MochiKit.Style.Coordinates(0, 0);
+            m.client = { x: 0, y: 0 };
             if (e.clientX || e.clientY) {
                 m.client.x = (!e.clientX || e.clientX < 0) ? 0 : e.clientX;
                 m.client.y = (!e.clientY || e.clientY < 0) ? 0 : e.clientY;
             }
 
-            m.page = new MochiKit.Style.Coordinates(0, 0);
+            m.page = { x: 0, y: 0 };
             if (e.pageX || e.pageY) {
                 m.page.x = (!e.pageX || e.pageX < 0) ? 0 : e.pageX;
                 m.page.y = (!e.pageY || e.pageY < 0) ? 0 : e.pageY;
             } else {
                 /*
 
                     The IE shortcut can be off by two. We fix it. See:
                     http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
 
                     This is similar to the method used in
                     MochiKit.Style.getElementPosition().
 
                 */
                 var de = MochiKit.DOM._document.documentElement;
                 var b = MochiKit.DOM._document.body;
 
                 m.page.x = e.clientX +
                     (de.scrollLeft || b.scrollLeft) -
                     (de.clientLeft || 0);
 
                 m.page.y = e.clientY +
                     (de.scrollTop || b.scrollTop) -
                     (de.clientTop || 0);
 
             }
             if (this.type() != 'mousemove' && this.type() != 'mousewheel') {
                 m.button = {};
                 m.button.left = false;
                 m.button.right = false;
                 m.button.middle = false;
 
                 /* we could check e.button, but which is more consistent */
                 if (e.which) {
                     m.button.left = (e.which == 1);
                     m.button.middle = (e.which == 2);
                     m.button.right = (e.which == 3);
 
                     /*
 
                         Mac browsers and right click:
 
                             - Safari doesn't fire any click events on a right
                               click:
                               http://bugs.webkit.org/show_bug.cgi?id=6595
 
                             - Firefox fires the event, and sets ctrlKey = true
 
                             - Opera fires the event, and sets metaKey = true
 
                         oncontextmenu is fired on right clicks between
                         browsers and across platforms.
 
                     */
 
                 } else {
                     m.button.left = !!(e.button & 1);
                     m.button.right = !!(e.button & 2);
                     m.button.middle = !!(e.button & 4);
                 }
             }
             if (this.type() == 'mousewheel') {
-                m.wheel = new MochiKit.Style.Coordinates(0, 0);
+                m.wheel = { x: 0, y: 0 };
                 if (e.wheelDeltaX || e.wheelDeltaY) {
                     m.wheel.x = e.wheelDeltaX / -40 || 0;
                     m.wheel.y = e.wheelDeltaY / -40 || 0;
                 } else if (e.wheelDelta) {
                     m.wheel.y = e.wheelDelta / -40;
                 } else {
                     m.wheel.y = e.detail || 0;
                 }
             }
             this._mouse = m;
             return m;
         }
         return undefined;
     },
 
     /** @id MochiKit.Signal.Event.prototype.stop */
     stop: function () {
         this.stopPropagation();
         this.preventDefault();
     },
 
     /** @id MochiKit.Signal.Event.prototype.stopPropagation */
     stopPropagation: function () {
         if (this._event.stopPropagation) {
             this._event.stopPropagation();
         } else {
             this._event.cancelBubble = true;
         }
     },
 
     /** @id MochiKit.Signal.Event.prototype.preventDefault */
     preventDefault: function () {
         if (this._event.preventDefault) {
             this._event.preventDefault();
         } else if (this._confirmUnload === null) {
             this._event.returnValue = false;
         }
     },
 
     _confirmUnload: null,
 
     /** @id MochiKit.Signal.Event.prototype.confirmUnload */
     confirmUnload: function (msg) {
         if (this.type() == 'beforeunload') {
             this._confirmUnload = msg;
             this._event.returnValue = msg;
         }
     }
 });
 
 /* Safari sets keyCode to these special values onkeypress. */
 MochiKit.Signal._specialMacKeys = {
     3: 'KEY_ENTER',
     63289: 'KEY_NUM_PAD_CLEAR',
     63276: 'KEY_PAGE_UP',
     63277: 'KEY_PAGE_DOWN',
     63275: 'KEY_END',
     63273: 'KEY_HOME',
     63234: 'KEY_ARROW_LEFT',
     63232: 'KEY_ARROW_UP',
     63235: 'KEY_ARROW_RIGHT',
     63233: 'KEY_ARROW_DOWN',
     63302: 'KEY_INSERT',
     63272: 'KEY_DELETE'
@@ -611,278 +612,290 @@ MochiKit.Base.update(MochiKit.Signal, {
             func = objOrFunc;
         }
         return [obj, func];
     },
 
     /** @id MochiKit.Signal.connect */
     connect: function (src, sig, objOrFunc/* optional */, funcOrStr) {
         if (typeof(src) == "string") {
             src = MochiKit.DOM.getElement(src);
         }
         var self = MochiKit.Signal;
 
         if (typeof(sig) != 'string') {
             throw new Error("'sig' must be a string");
         }
 
         var destPair = self._getDestPair(objOrFunc, funcOrStr);
         var obj = destPair[0];
         var func = destPair[1];
         if (typeof(obj) == 'undefined' || obj === null) {
             obj = src;
         }
 
         var isDOM = !!(src.addEventListener || src.attachEvent);
         if (isDOM && (sig === "onmouseenter" || sig === "onmouseleave")
                   && !self._browserAlreadyHasMouseEnterAndLeave()) {
             var listener = self._mouseEnterListener(src, sig.substr(2), func, obj);
             if (sig === "onmouseenter") {
                 sig = "onmouseover";
             } else {
                 sig = "onmouseout";
             }
         } else if (isDOM && sig == "onmousewheel" && self._browserLacksMouseWheelEvent()) {
             var listener = self._listener(src, sig, func, obj, isDOM);
             sig = "onDOMMouseScroll";
         } else {
             var listener = self._listener(src, sig, func, obj, isDOM);
         }
 
         if (src.addEventListener) {
             src.addEventListener(sig.substr(2), listener, false);
         } else if (src.attachEvent) {
             src.attachEvent(sig, listener); // useCapture unsupported
         }
 
         var ident = new MochiKit.Signal.Ident({
             source: src, 
             signal: sig, 
             listener: listener, 
             isDOM: isDOM, 
             objOrFunc: objOrFunc, 
             funcOrStr: funcOrStr, 
             connected: true
         });
         self._observers.push(ident);
 
         if (!isDOM && typeof(src.__connect__) == 'function') {
             var args = MochiKit.Base.extend([ident], arguments, 1);
             src.__connect__.apply(src, args);
         }
 
         return ident;
     },
 
+    /** @id MochiKit.Signal.connectOnce */
+    connectOnce: function (src, sig, objOrFunc/* optional */, funcOrStr) {
+        var self = MochiKit.Signal;
+        var ident1 = self.connect(src, sig, objOrFunc, funcOrStr);
+        var ident2;
+        ident2 = self.connect(src, sig, function() {
+            self.disconnect(ident1);
+            self.disconnect(ident2);
+        });
+        return ident1;
+    },
+
     _disconnect: function (ident) {
         // already disconnected
         if (!ident.connected) {
             return;
         }
         ident.connected = false;
         var src = ident.source;
         var sig = ident.signal;
         var listener = ident.listener;
         // check isDOM
         if (!ident.isDOM) {
             if (typeof(src.__disconnect__) == 'function') {
                 src.__disconnect__(ident, sig, ident.objOrFunc, ident.funcOrStr);
             }
             return;
         }
         if (src.removeEventListener) {
             src.removeEventListener(sig.substr(2), listener, false);
         } else if (src.detachEvent) {
             src.detachEvent(sig, listener); // useCapture unsupported
         } else {
             throw new Error("'src' must be a DOM element");
         }
     },
 
      /** @id MochiKit.Signal.disconnect */
     disconnect: function (ident) {
         var self = MochiKit.Signal;
         var observers = self._observers;
         var m = MochiKit.Base;
         if (arguments.length > 1) {
             // compatibility API
             var src = arguments[0];
             if (typeof(src) == "string") {
                 src = MochiKit.DOM.getElement(src);
             }
             var sig = arguments[1];
             var obj = arguments[2];
             var func = arguments[3];
             for (var i = observers.length - 1; i >= 0; i--) {
                 var o = observers[i];
                 if (o.source === src && o.signal === sig && o.objOrFunc === obj && o.funcOrStr === func) {
                     self._disconnect(o);
-                    if (!self._lock) {
+                    if (self._lock === 0) {
                         observers.splice(i, 1);
                     } else {
                         self._dirty = true;
                     }
                     return true;
                 }
             }
         } else {
             var idx = m.findIdentical(observers, ident);
             if (idx >= 0) {
                 self._disconnect(ident);
-                if (!self._lock) {
+                if (self._lock === 0) {
                     observers.splice(idx, 1);
                 } else {
                     self._dirty = true;
                 }
                 return true;
             }
         }
         return false;
     },
 
     /** @id MochiKit.Signal.disconnectAllTo */
     disconnectAllTo: function (objOrFunc, /* optional */funcOrStr) {
         var self = MochiKit.Signal;
         var observers = self._observers;
         var disconnect = self._disconnect;
-        var locked = self._lock;
+        var lock = self._lock;
         var dirty = self._dirty;
         if (typeof(funcOrStr) === 'undefined') {
             funcOrStr = null;
         }
         for (var i = observers.length - 1; i >= 0; i--) {
             var ident = observers[i];
             if (ident.objOrFunc === objOrFunc &&
                     (funcOrStr === null || ident.funcOrStr === funcOrStr)) {
                 disconnect(ident);
-                if (locked) {
-                    dirty = true;
-                } else {
+                if (lock === 0) {
                     observers.splice(i, 1);
+                } else {
+                    dirty = true;
                 }
             }
         }
         self._dirty = dirty;
     },
 
     /** @id MochiKit.Signal.disconnectAll */
     disconnectAll: function (src/* optional */, sig) {
         if (typeof(src) == "string") {
             src = MochiKit.DOM.getElement(src);
         }
         var m = MochiKit.Base;
         var signals = m.flattenArguments(m.extend(null, arguments, 1));
         var self = MochiKit.Signal;
         var disconnect = self._disconnect;
         var observers = self._observers;
         var i, ident;
-        var locked = self._lock;
+        var lock = self._lock;
         var dirty = self._dirty;
         if (signals.length === 0) {
             // disconnect all
             for (i = observers.length - 1; i >= 0; i--) {
                 ident = observers[i];
                 if (ident.source === src) {
                     disconnect(ident);
-                    if (!locked) {
+                    if (lock === 0) {
                         observers.splice(i, 1);
                     } else {
                         dirty = true;
                     }
                 }
             }
         } else {
             var sigs = {};
             for (i = 0; i < signals.length; i++) {
                 sigs[signals[i]] = true;
             }
             for (i = observers.length - 1; i >= 0; i--) {
                 ident = observers[i];
                 if (ident.source === src && ident.signal in sigs) {
                     disconnect(ident);
-                    if (!locked) {
+                    if (lock === 0) {
                         observers.splice(i, 1);
                     } else {
                         dirty = true;
                     }
                 }
             }
         }
         self._dirty = dirty;
     },
 
     /** @id MochiKit.Signal.signal */
     signal: function (src, sig) {
         var self = MochiKit.Signal;
         var observers = self._observers;
         if (typeof(src) == "string") {
             src = MochiKit.DOM.getElement(src);
         }
         var args = MochiKit.Base.extend(null, arguments, 2);
         var errors = [];
-        self._lock = true;
+        self._lock++;
         for (var i = 0; i < observers.length; i++) {
             var ident = observers[i];
             if (ident.source === src && ident.signal === sig &&
                     ident.connected) {
                 try {
                     if (ident.isDOM && ident.funcOrStr != null) {
                         var obj = ident.objOrFunc;
                         obj[ident.funcOrStr].apply(obj, args);
                     } else if (ident.isDOM) {
                         ident.objOrFunc.apply(src, args);
                     } else {
                         ident.listener.apply(src, args);
                     }
                 } catch (e) {
                     errors.push(e);
                 }
             }
         }
-        self._lock = false;
-        if (self._dirty) {
+        self._lock--;
+        if (self._lock === 0 && self._dirty) {
             self._dirty = false;
             for (var i = observers.length - 1; i >= 0; i--) {
                 if (!observers[i].connected) {
                     observers.splice(i, 1);
                 }
             }
         }
         if (errors.length == 1) {
             throw errors[0];
         } else if (errors.length > 1) {
             var e = new Error("Multiple errors thrown in handling 'sig', see errors property");
             e.errors = errors;
             throw e;
         }
     }
 
 });
 
 MochiKit.Signal.__new__ = function (win) {
     var m = MochiKit.Base;
     this._document = document;
     this._window = win;
-    this._lock = false;
+    this._lock = 0;
     this._dirty = false;
 
     try {
         this.connect(window, 'onunload', this._unloadCache);
     } catch (e) {
         // pass: might not be a browser
     }
 
     m.nameFunctions(this);
 };
 
 MochiKit.Signal.__new__(this);
 
 //
 // XXX: Internet Explorer blows
 //
 if (MochiKit.__export__) {
     connect = MochiKit.Signal.connect;
     disconnect = MochiKit.Signal.disconnect;
     disconnectAll = MochiKit.Signal.disconnectAll;
     signal = MochiKit.Signal.signal;
 }
 
 MochiKit.Base._exportSymbols(this, MochiKit.Signal);
diff --git a/frontend/gamma/js/MochiKit/Sortable.js b/frontend/gamma/js/MochiKit/Sortable.js
index 863b506..ca9db21 100644
--- a/frontend/gamma/js/MochiKit/Sortable.js
+++ b/frontend/gamma/js/MochiKit/Sortable.js
@@ -1,73 +1,73 @@
 /***
 Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
     Mochi-ized By Thomas Herve (_firstname_@nimail.org)
 
 See scriptaculous.js for full license.
 
 ***/
 
-MochiKit.Base._module('Sortable', '1.5', ['Base', 'Iter', 'DOM', 'Position', 'DragAndDrop']);
+MochiKit.Base.module(MochiKit, 'Sortable', '1.5', ['Base', 'Iter', 'DOM', 'Position', 'DragAndDrop']);
 
 MochiKit.Base.update(MochiKit.Sortable, {
     __export__: false,
 
     /***
 
     Manage sortables. Mainly use the create function to add a sortable.
 
     ***/
     sortables: {},
 
     _findRootElement: function (element) {
         while (element.tagName.toUpperCase() != "BODY") {
             if (element.id && MochiKit.Sortable.sortables[element.id]) {
                 return element;
             }
             element = element.parentNode;
         }
     },
 
     _createElementId: function(element) {
         if (element.id == null || element.id == "") {
             var d = MochiKit.DOM;
             var id;
             var count = 1;
             while (d.getElement(id = "sortable" + count) != null) {
                 count += 1;
             }
             d.setNodeAttribute(element, "id", id);
         }
     },
 
     /** @id MochiKit.Sortable.options */
     options: function (element) {
         element = MochiKit.Sortable._findRootElement(MochiKit.DOM.getElement(element));
         if (!element) {
             return;
         }
         return MochiKit.Sortable.sortables[element.id];
     },
 
     /** @id MochiKit.Sortable.destroy */
     destroy: function (element){
         var s = MochiKit.Sortable.options(element);
         var b = MochiKit.Base;
         var d = MochiKit.DragAndDrop;
 
         if (s) {
             MochiKit.Signal.disconnect(s.startHandle);
             MochiKit.Signal.disconnect(s.endHandle);
             b.map(function (dr) {
                 d.Droppables.remove(dr);
             }, s.droppables);
             b.map(function (dr) {
                 dr.destroy();
             }, s.draggables);
 
             delete MochiKit.Sortable.sortables[s.element.id];
         }
     },
 
     /** @id MochiKit.Sortable.create */
     create: function (element, options) {
         element = MochiKit.DOM.getElement(element);
@@ -118,137 +118,137 @@ MochiKit.Base.update(MochiKit.Sortable, {
             scroll: false,
 
             /** @id MochiKit.Sortable.scrollSensitivity */
             scrollSensitivity: 20,
 
             /** @id MochiKit.Sortable.scrollSpeed */
             scrollSpeed: 15,
 
             /** @id MochiKit.Sortable.format */
             format: /^[^_]*_(.*)$/,
 
             /** @id MochiKit.Sortable.onChange */
             onChange: MochiKit.Base.noop,
 
             /** @id MochiKit.Sortable.onUpdate */
             onUpdate: MochiKit.Base.noop,
 
             /** @id MochiKit.Sortable.accept */
             accept: null
         }, options);
 
         // clear any old sortable with same element
         self.destroy(element);
 
         // build options for the draggables
         var options_for_draggable = {
             revert: true,
             ghosting: options.ghosting,
             scroll: options.scroll,
             scrollSensitivity: options.scrollSensitivity,
             scrollSpeed: options.scrollSpeed,
             constraint: options.constraint,
             handle: options.handle
         };
 
         if (options.starteffect) {
             options_for_draggable.starteffect = options.starteffect;
         }
 
         if (options.reverteffect) {
             options_for_draggable.reverteffect = options.reverteffect;
         } else if (options.ghosting) {
             options_for_draggable.reverteffect = function (innerelement) {
                 innerelement.style.top = 0;
                 innerelement.style.left = 0;
             };
         }
 
         if (options.endeffect) {
             options_for_draggable.endeffect = options.endeffect;
         }
 
         if (options.zindex) {
             options_for_draggable.zindex = options.zindex;
         }
 
         // build options for the droppables
         var options_for_droppable = {
             overlap: options.overlap,
             containment: options.containment,
             hoverclass: options.hoverclass,
             onhover: self.onHover,
             tree: options.tree,
             accept: options.accept
-        }
+        };
 
         var options_for_tree = {
             onhover: self.onEmptyHover,
             overlap: options.overlap,
             containment: options.containment,
             hoverclass: options.hoverclass,
             accept: options.accept
-        }
+        };
 
         // fix for gecko engine
         MochiKit.DOM.removeEmptyTextNodes(element);
 
         options.draggables = [];
         options.droppables = [];
 
         // drop on empty handling
         if (options.dropOnEmpty || options.tree) {
             new MochiKit.DragAndDrop.Droppable(element, options_for_tree);
             options.droppables.push(element);
         }
         MochiKit.Base.map(function (e) {
             // handles are per-draggable
             var handle = options.handle ?
                 MochiKit.DOM.getFirstElementByTagAndClassName(null,
                     options.handle, e) : e;
             options.draggables.push(
                 new MochiKit.DragAndDrop.Draggable(e,
                     MochiKit.Base.update(options_for_draggable,
                                          {handle: handle})));
             new MochiKit.DragAndDrop.Droppable(e, options_for_droppable);
             if (options.tree) {
                 e.treeNode = element;
             }
             options.droppables.push(e);
         }, (self.findElements(element, options) || []));
 
         if (options.tree) {
             MochiKit.Base.map(function (e) {
                 new MochiKit.DragAndDrop.Droppable(e, options_for_tree);
                 e.treeNode = element;
                 options.droppables.push(e);
             }, (self.findTreeElements(element, options) || []));
         }
 
         // keep reference
         self.sortables[element.id] = options;
 
         options.lastValue = self.serialize(element);
         options.startHandle = MochiKit.Signal.connect(MochiKit.DragAndDrop.Draggables, 'start',
                                 MochiKit.Base.partial(self.onStart, element));
         options.endHandle = MochiKit.Signal.connect(MochiKit.DragAndDrop.Draggables, 'end',
                                 MochiKit.Base.partial(self.onEnd, element));
     },
 
     /** @id MochiKit.Sortable.onStart */
     onStart: function (element, draggable) {
         var self = MochiKit.Sortable;
         var options = self.options(element);
         options.lastValue = self.serialize(options.element);
     },
 
     /** @id MochiKit.Sortable.onEnd */
     onEnd: function (element, draggable) {
         var self = MochiKit.Sortable;
         self.unmark();
         var options = self.options(element);
         if (options.lastValue != self.serialize(options.element)) {
             options.onUpdate(options.element);
         }
     },
 
     // return all suitable-for-sortable elements in a guaranteed order
@@ -369,174 +369,174 @@ MochiKit.Base.update(MochiKit.Sortable, {
 
             self.options(oldParentNode).onChange(element);
             droponOptions.onChange(element);
         }
     },
 
     /** @id MochiKit.Sortable.unmark */
     unmark: function () {
         var m = MochiKit.Sortable._marker;
         if (m) {
             MochiKit.Style.hideElement(m);
         }
     },
 
     /** @id MochiKit.Sortable.mark */
     mark: function (dropon, position) {
         // mark on ghosting only
         var d = MochiKit.DOM;
         var self = MochiKit.Sortable;
         var sortable = self.options(dropon.parentNode);
         if (sortable && !sortable.ghosting) {
             return;
         }
 
         if (!self._marker) {
             self._marker = d.getElement('dropmarker') ||
                         document.createElement('DIV');
             MochiKit.Style.hideElement(self._marker);
             d.addElementClass(self._marker, 'dropmarker');
             self._marker.style.position = 'absolute';
             document.getElementsByTagName('body').item(0).appendChild(self._marker);
         }
         var offsets = MochiKit.Position.cumulativeOffset(dropon);
         self._marker.style.left = offsets.x + 'px';
         self._marker.style.top = offsets.y + 'px';
 
         if (position == 'after') {
             if (sortable.overlap == 'horizontal') {
                 self._marker.style.left = (offsets.x + dropon.clientWidth) + 'px';
             } else {
                 self._marker.style.top = (offsets.y + dropon.clientHeight) + 'px';
             }
         }
         MochiKit.Style.showElement(self._marker);
     },
 
     _tree: function (element, options, parent) {
         var self = MochiKit.Sortable;
         var children = self.findElements(element, options) || [];
 
         for (var i = 0; i < children.length; ++i) {
             var match = children[i].id.match(options.format);
 
             if (!match) {
                 continue;
             }
 
             var child = {
                 id: encodeURIComponent(match ? match[1] : null),
                 element: element,
                 parent: parent,
                 children: [],
                 position: parent.children.length,
                 container: self._findChildrenElement(children[i], options.treeTag.toUpperCase())
-            }
+            };
 
             /* Get the element containing the children and recurse over it */
             if (child.container) {
-                self._tree(child.container, options, child)
+                self._tree(child.container, options, child);
             }
 
             parent.children.push (child);
         }
 
         return parent;
     },
 
     /* Finds the first element of the given tag type within a parent element.
        Used for finding the first LI[ST] within a L[IST]I[TEM].*/
     _findChildrenElement: function (element, containerTag) {
         if (element && element.hasChildNodes) {
             containerTag = containerTag.toUpperCase();
             for (var i = 0; i < element.childNodes.length; ++i) {
                 if (element.childNodes[i].tagName.toUpperCase() == containerTag) {
                     return element.childNodes[i];
                 }
             }
         }
         return null;
     },
 
     /** @id MochiKit.Sortable.tree */
     tree: function (element, options) {
         element = MochiKit.DOM.getElement(element);
         var sortableOptions = MochiKit.Sortable.options(element);
         options = MochiKit.Base.update({
             tag: sortableOptions.tag,
             treeTag: sortableOptions.treeTag,
             only: sortableOptions.only,
             name: element.id,
             format: sortableOptions.format
         }, options || {});
 
         var root = {
             id: null,
             parent: null,
             children: new Array,
             container: element,
             position: 0
-        }
+        };
 
         return MochiKit.Sortable._tree(element, options, root);
     },
 
     /**
      * Specifies the sequence for the Sortable.
      * @param {Node} element    Element to use as the Sortable.
      * @param {Object} newSequence    New sequence to use.
      * @param {Object} options    Options to use fro the Sortable.
      */
     setSequence: function (element, newSequence, options) {
         var self = MochiKit.Sortable;
         var b = MochiKit.Base;
         element = MochiKit.DOM.getElement(element);
         options = b.update(self.options(element), options || {});
 
         var nodeMap = {};
         b.map(function (n) {
             var m = n.id.match(options.format);
             if (m) {
                 nodeMap[m[1]] = [n, n.parentNode];
             }
             n.parentNode.removeChild(n);
         }, self.findElements(element, options));
 
         b.map(function (ident) {
             var n = nodeMap[ident];
             if (n) {
                 n[1].appendChild(n[0]);
                 delete nodeMap[ident];
             }
         }, newSequence);
     },
 
     /* Construct a [i] index for a particular node */
     _constructIndex: function (node) {
         var index = '';
         do {
             if (node.id) {
                 index = '[' + node.position + ']' + index;
             }
         } while ((node = node.parent) != null);
         return index;
     },
 
     /** @id MochiKit.Sortable.sequence */
     sequence: function (element, options) {
         element = MochiKit.DOM.getElement(element);
         var self = MochiKit.Sortable;
         var options = MochiKit.Base.update(self.options(element), options || {});
 
         return MochiKit.Base.map(function (item) {
             return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
         }, MochiKit.DOM.getElement(self.findElements(element, options) || []));
     },
 
     /**
      * Serializes the content of a Sortable. Useful to send this content through a XMLHTTPRequest.
      * These options override the Sortable options for the serialization only.
      * @param {Node} element    Element to serialize.
      * @param {Object} options    Serialization options.
      */
     serialize: function (element, options) {
         element = MochiKit.DOM.getElement(element);
diff --git a/frontend/gamma/js/MochiKit/Style.js b/frontend/gamma/js/MochiKit/Style.js
index 7f10117..740fd2f 100644
--- a/frontend/gamma/js/MochiKit/Style.js
+++ b/frontend/gamma/js/MochiKit/Style.js
@@ -1,75 +1,78 @@
 /***
 
 MochiKit.Style 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005-2006 Bob Ippolito, Beau Hartshorne.  All rights Reserved.
 
+The MochiKit.Style.getElementPosition function is adapted from
+YAHOO.util.Dom.getXY v0.9.0. which is copyrighted by Yahoo! Inc.
+
 ***/
 
-MochiKit.Base._module('Style', '1.5', ['Base', 'DOM']);
+MochiKit.Base.module(MochiKit, 'Style', '1.5', ['Base', 'DOM']);
 
 
 /** @id MochiKit.Style.Dimensions */
 MochiKit.Style.Dimensions = function (w, h) {
     if (!(this instanceof MochiKit.Style.Dimensions)) {
         return new MochiKit.Style.Dimensions(w, h);
     }
     this.w = w;
     this.h = h;
 };
 
 MochiKit.Style.Dimensions.prototype.__repr__ = function () {
     var repr = MochiKit.Base.repr;
     return '{w: '  + repr(this.w) + ', h: ' + repr(this.h) + '}';
 };
 
 MochiKit.Style.Dimensions.prototype.toString = function () {
     return this.__repr__();
 };
 
 
 /** @id MochiKit.Style.Coordinates */
 MochiKit.Style.Coordinates = function (x, y) {
     if (!(this instanceof MochiKit.Style.Coordinates)) {
         return new MochiKit.Style.Coordinates(x, y);
     }
     this.x = x;
     this.y = y;
 };
 
 MochiKit.Style.Coordinates.prototype.__repr__ = function () {
     var repr = MochiKit.Base.repr;
     return '{x: '  + repr(this.x) + ', y: ' + repr(this.y) + '}';
 };
 
 MochiKit.Style.Coordinates.prototype.toString = function () {
     return this.__repr__();
 };
 
 
 MochiKit.Base.update(MochiKit.Style, {
 
     /** @id MochiKit.Style.getStyle */
     getStyle: function (elem, cssProperty) {
         var dom = MochiKit.DOM;
         var d = dom._document;
 
         elem = dom.getElement(elem);
         cssProperty = MochiKit.Base.camelize(cssProperty);
 
         if (!elem || elem == d) {
             return undefined;
         }
         if (cssProperty == 'opacity' && typeof(elem.filters) != 'undefined') {
             var opacity = (MochiKit.Style.getStyle(elem, 'filter') || '').match(/alpha\(opacity=(.*)\)/);
             if (opacity && opacity[1]) {
                 return parseFloat(opacity[1]) / 100;
             }
             return 1.0;
         }
         if (cssProperty == 'float' || cssProperty == 'cssFloat' || cssProperty == 'styleFloat') {
             if (elem.style["float"]) {
                 return elem.style["float"];
             } else if (elem.style.cssFloat) {
@@ -118,179 +121,179 @@ MochiKit.Base.update(MochiKit.Style, {
     setStyle: function (elem, style) {
         elem = MochiKit.DOM.getElement(elem);
         for (var name in style) {
             switch (name) {
             case 'opacity':
                 MochiKit.Style.setOpacity(elem, style[name]);
                 break;
             case 'float':
             case 'cssFloat':
             case 'styleFloat':
                 if (typeof(elem.style["float"]) != "undefined") {
                     elem.style["float"] = style[name];
                 } else if (typeof(elem.style.cssFloat) != "undefined") {
                     elem.style.cssFloat = style[name];
                 } else {
                     elem.style.styleFloat = style[name];
                 }
                 break;
             default:
                 elem.style[MochiKit.Base.camelize(name)] = style[name];
             }
         }
     },
 
     /** @id MochiKit.Style.setOpacity */
     setOpacity: function (elem, o) {
         elem = MochiKit.DOM.getElement(elem);
         var self = MochiKit.Style;
         if (o == 1) {
             var toSet = /Gecko/.test(navigator.userAgent) && !(/Konqueror|AppleWebKit|KHTML/.test(navigator.userAgent));
             elem.style["opacity"] = toSet ? 0.999999 : 1.0;
             if (/MSIE/.test(navigator.userAgent)) {
                 elem.style['filter'] =
                     self.getStyle(elem, 'filter').replace(/alpha\([^\)]*\)/gi, '');
             }
         } else {
             if (o < 0.00001) {
                 o = 0;
             }
             elem.style["opacity"] = o;
             if (/MSIE/.test(navigator.userAgent)) {
                 elem.style['filter'] =
                     self.getStyle(elem, 'filter').replace(/alpha\([^\)]*\)/gi, '') + 'alpha(opacity=' + o * 100 + ')';
             }
         }
     },
 
     /*
 
         getElementPosition is adapted from YAHOO.util.Dom.getXY v0.9.0.
         Copyright: Copyright (c) 2006, Yahoo! Inc. All rights reserved.
         License: BSD, http://developer.yahoo.net/yui/license.txt
 
     */
 
     /** @id MochiKit.Style.getElementPosition */
     getElementPosition: function (elem, /* optional */relativeTo) {
         var self = MochiKit.Style;
         var dom = MochiKit.DOM;
         var isCoordinates = function (o) {
             return o != null &&
                    o.nodeType == null &&
                    typeof(o.x) == "number" &&
                    typeof(o.y) == "number";
-        }
+        };
 
         if (typeof(elem) == "string") {
             elem = dom.getElement(elem);
         }
         if (elem == null ||
             (!isCoordinates(elem) && self.getStyle(elem, 'display') == 'none')) {
             return undefined;
         }
 
         var c = new self.Coordinates(0, 0);
         var box = null;
         var parent = null;
 
         var d = MochiKit.DOM._document;
         var de = d.documentElement;
         var b = d.body;
 
-        if (!elem.parentNode && elem.x && elem.y) {
+        if (isCoordinates(elem)) {
             /* it's just a MochiKit.Style.Coordinates object */
             c.x += elem.x || 0;
             c.y += elem.y || 0;
         } else if (elem.getBoundingClientRect) { // IE shortcut
             /*
 
                 The IE shortcut can be off by two. We fix it. See:
                 http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
 
                 This is similar to the method used in
                 MochiKit.Signal.Event.mouse().
 
             */
             box = elem.getBoundingClientRect();
 
             c.x += box.left +
                 (de.scrollLeft || b.scrollLeft) -
                 (de.clientLeft || 0);
 
             c.y += box.top +
                 (de.scrollTop || b.scrollTop) -
                 (de.clientTop || 0);
 
         } else if (elem.offsetParent) {
             c.x += elem.offsetLeft;
             c.y += elem.offsetTop;
             parent = elem.offsetParent;
 
             if (parent != elem) {
                 while (parent) {
-                    c.x += parseInt(parent.style.borderLeftWidth) || 0;
-                    c.y += parseInt(parent.style.borderTopWidth) || 0;
+                    c.x += parseInt(parent.style.borderLeftWidth, 10) || 0;
+                    c.y += parseInt(parent.style.borderTopWidth, 10) || 0;
                     c.x += parent.offsetLeft;
                     c.y += parent.offsetTop;
                     parent = parent.offsetParent;
                 }
             }
 
             /*
 
                 Opera < 9 and old Safari (absolute) incorrectly account for
                 body offsetTop and offsetLeft.
 
             */
             var ua = navigator.userAgent.toLowerCase();
             if ((typeof(opera) != 'undefined' &&
                 parseFloat(opera.version()) < 9) ||
                 (ua.indexOf('AppleWebKit') != -1 &&
                 self.getStyle(elem, 'position') == 'absolute')) {
 
                 c.x -= b.offsetLeft;
                 c.y -= b.offsetTop;
 
             }
 
             // Adjust position for strange Opera scroll bug
             if (elem.parentNode) {
                 parent = elem.parentNode;
             } else {
                 parent = null;
             }
             while (parent) {
                 var tagName = parent.tagName.toUpperCase();
                 if (tagName === 'BODY' || tagName === 'HTML') {
                     break;
                 }
                 var disp = self.getStyle(parent, 'display');
                 // Handle strange Opera bug for some display
                 if (disp.search(/^inline|table-row.*$/i)) {
                     c.x -= parent.scrollLeft;
                     c.y -= parent.scrollTop;
                 }
                 if (parent.parentNode) {
                     parent = parent.parentNode;
                 } else {
                     parent = null;
                 }
             }
         }
 
         if (relativeTo) {
             relativeTo = arguments.callee(relativeTo);
             if (relativeTo) {
                 c.x -= (relativeTo.x || 0);
                 c.y -= (relativeTo.y || 0);
             }
         }
 
         return c;
     },
 
     /** @id MochiKit.Style.setElementPosition */
     setElementPosition: function (elem, newPos/* optional */, units) {
         elem = MochiKit.DOM.getElement(elem);
         if (typeof(units) == 'undefined') {
             units = 'px';
@@ -329,129 +332,129 @@ MochiKit.Base.update(MochiKit.Style, {
             element.style.position = element.style.top = element.style.left = element.style.bottom = element.style.right = '';
         }
     },
 
     /** @id MochiKit.Style.makeClipping */
     makeClipping: function (element) {
         element = MochiKit.DOM.getElement(element);
         var s = element.style;
         var oldOverflow = { 'overflow': s.overflow,
                             'overflow-x': s.overflowX,
                             'overflow-y': s.overflowY };
         if ((MochiKit.Style.getStyle(element, 'overflow') || 'visible') != 'hidden') {
             element.style.overflow = 'hidden';
             element.style.overflowX = 'hidden';
             element.style.overflowY = 'hidden';
         }
         return oldOverflow;
     },
 
     /** @id MochiKit.Style.undoClipping */
     undoClipping: function (element, overflow) {
         element = MochiKit.DOM.getElement(element);
         if (typeof(overflow) == 'string') {
             element.style.overflow = overflow;
         } else if (overflow != null) {
             element.style.overflow = overflow['overflow'];
             element.style.overflowX = overflow['overflow-x'];
             element.style.overflowY = overflow['overflow-y'];
         }
     },
 
     /** @id MochiKit.Style.getElementDimensions */
     getElementDimensions: function (elem, contentSize/*optional*/) {
         var self = MochiKit.Style;
         var dom = MochiKit.DOM;
         if (typeof(elem.w) == 'number' || typeof(elem.h) == 'number') {
             return new self.Dimensions(elem.w || 0, elem.h || 0);
         }
         elem = dom.getElement(elem);
         if (!elem) {
             return undefined;
         }
         var disp = self.getStyle(elem, 'display');
         // display can be empty/undefined on WebKit/KHTML
         if (disp == 'none' || disp == '' || typeof(disp) == 'undefined') {
             var s = elem.style;
             var originalVisibility = s.visibility;
             var originalPosition = s.position;
             var originalDisplay = s.display;
             s.visibility = 'hidden';
             s.position = 'absolute';
             s.display = self._getDefaultDisplay(elem);
             var originalWidth = elem.offsetWidth;
             var originalHeight = elem.offsetHeight;
             s.display = originalDisplay;
             s.position = originalPosition;
             s.visibility = originalVisibility;
         } else {
             originalWidth = elem.offsetWidth || 0;
             originalHeight = elem.offsetHeight || 0;
         }
         if (contentSize) {
             var tableCell = 'colSpan' in elem && 'rowSpan' in elem;
             var collapse = (tableCell && elem.parentNode && self.getStyle(
-                    elem.parentNode, 'borderCollapse') == 'collapse')
+                    elem.parentNode, 'borderCollapse') == 'collapse');
             if (collapse) {
                 if (/MSIE/.test(navigator.userAgent)) {
                     var borderLeftQuota = elem.previousSibling? 0.5 : 1;
                     var borderRightQuota = elem.nextSibling? 0.5 : 1;
                 }
                 else {
                     var borderLeftQuota = 0.5;
                     var borderRightQuota = 0.5;
                 }
             } else {
                 var borderLeftQuota = 1;
                 var borderRightQuota = 1;
             }
             originalWidth -= Math.round(
                 (parseFloat(self.getStyle(elem, 'paddingLeft')) || 0)
               + (parseFloat(self.getStyle(elem, 'paddingRight')) || 0)
               + borderLeftQuota *
                 (parseFloat(self.getStyle(elem, 'borderLeftWidth')) || 0)
               + borderRightQuota *
                 (parseFloat(self.getStyle(elem, 'borderRightWidth')) || 0)
             );
             if (tableCell) {
                 if (/Gecko|Opera/.test(navigator.userAgent)
                     && !/Konqueror|AppleWebKit|KHTML/.test(navigator.userAgent)) {
                     var borderHeightQuota = 0;
                 } else if (/MSIE/.test(navigator.userAgent)) {
                     var borderHeightQuota = 1;
                 } else {
                     var borderHeightQuota = collapse? 0.5 : 1;
                 }
             } else {
                 var borderHeightQuota = 1;
             }
             originalHeight -= Math.round(
                 (parseFloat(self.getStyle(elem, 'paddingTop')) || 0)
               + (parseFloat(self.getStyle(elem, 'paddingBottom')) || 0)
               + borderHeightQuota * (
                 (parseFloat(self.getStyle(elem, 'borderTopWidth')) || 0)
               + (parseFloat(self.getStyle(elem, 'borderBottomWidth')) || 0))
             );
         }
         return new self.Dimensions(originalWidth, originalHeight);
     },
 
     /** @id MochiKit.Style.setElementDimensions */
     setElementDimensions: function (elem, newSize/* optional */, units) {
         elem = MochiKit.DOM.getElement(elem);
         if (typeof(units) == 'undefined') {
             units = 'px';
         }
         var newStyle = {};
         var isUndefNull = MochiKit.Base.isUndefinedOrNull;
         if (!isUndefNull(newSize.w)) {
             newStyle['width'] = newSize.w + units;
         }
         if (!isUndefNull(newSize.h)) {
             newStyle['height'] = newSize.h + units;
         }
         MochiKit.DOM.updateNodeAttributes(elem, {'style': newStyle});
     },
 
     _getDefaultDisplay: function (elem) {
         var self = MochiKit.Style;
         var dom = MochiKit.DOM;
@@ -482,77 +485,77 @@ MochiKit.Base.update(MochiKit.Style, {
         var b = MochiKit.DOM._document.body;
         if (w.innerWidth) {
             d.w = w.innerWidth;
             d.h = w.innerHeight;
         } else if (b && b.parentElement && b.parentElement.clientWidth) {
             d.w = b.parentElement.clientWidth;
             d.h = b.parentElement.clientHeight;
         } else if (b && b.clientWidth) {
             d.w = b.clientWidth;
             d.h = b.clientHeight;
         }
         return d;
     },
 
     /** @id MochiKit.Style.getViewportPosition */
     getViewportPosition: function () {
         var c = new MochiKit.Style.Coordinates(0, 0);
         var d = MochiKit.DOM._document;
         var de = d.documentElement;
         var db = d.body;
         if (de && (de.scrollTop || de.scrollLeft)) {
             c.x = de.scrollLeft;
             c.y = de.scrollTop;
         } else if (db) {
             c.x = db.scrollLeft;
             c.y = db.scrollTop;
         }
         return c;
     },
 
     __new__: function () {
         var m = MochiKit.Base;
 
         var inlines = ['A','ABBR','ACRONYM','B','BASEFONT','BDO','BIG','BR',
                        'CITE','CODE','DFN','EM','FONT','I','IMG','KBD','LABEL',
                        'Q','S','SAMP','SMALL','SPAN','STRIKE','STRONG','SUB',
                        'SUP','TEXTAREA','TT','U','VAR'];
         this._defaultDisplay = { 'TABLE': 'table',
                                  'THEAD': 'table-header-group',
                                  'TBODY': 'table-row-group',
                                  'TFOOT': 'table-footer-group',
                                  'COLGROUP': 'table-column-group',
                                  'COL': 'table-column',
                                  'TR': 'table-row',
                                  'TD': 'table-cell',
                                  'TH': 'table-cell',
                                  'CAPTION': 'table-caption',
                                  'LI': 'list-item',
                                  'INPUT': 'inline-block',
                                  'SELECT': 'inline-block' };
         // CSS 'display' support in IE6/7 is just broken...
         if (/MSIE/.test(navigator.userAgent)) {
             for (var k in this._defaultDisplay) {
                 var v = this._defaultDisplay[k];
                 if (v.indexOf('table') == 0) {
                     this._defaultDisplay[k] = 'block';
                 }
             }
         }
         for (var i = 0; i < inlines.length; i++) {
             this._defaultDisplay[inlines[i]] = 'inline';
         }
 
         // Backwards compatibility aliases
-        m._deprecated(this, 'elementPosition', 'MochiKit.Style.getElementPosition', '1.3');
-        m._deprecated(this, 'elementDimensions', 'MochiKit.Style.getElementDimensions', '1.3');
+        m._deprecated(this, 'elementPosition', 'MochiKit.Style.getElementPosition', '1.3', true);
+        m._deprecated(this, 'elementDimensions', 'MochiKit.Style.getElementDimensions', '1.3', true);
 
         this.hideElement = m.partial(this.setDisplayForElement, 'none');
         // TODO: showElement could be improved by using getDefaultDisplay.
         this.showElement = m.partial(this.setDisplayForElement, 'block');
 
         m.nameFunctions(this);
     }
 });
 
 MochiKit.Style.__new__();
 MochiKit.Base._exportSymbols(this, MochiKit.Style);
diff --git a/frontend/gamma/js/MochiKit/Test.js b/frontend/gamma/js/MochiKit/Test.js
index 9520ab2..f29670f 100644
--- a/frontend/gamma/js/MochiKit/Test.js
+++ b/frontend/gamma/js/MochiKit/Test.js
@@ -1,75 +1,75 @@
 /***
 
 MochiKit.Test 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Test', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Test', '1.5', ['Base']);
 
 MochiKit.Test.runTests = function (obj) {
     if (typeof(obj) == "string") {
         // TODO: Remove this temporary API change advertisement
         throw new TypeError("Automatic module import not supported, call runTests() with proper object: " + obj);
     }
     var suite = new MochiKit.Test.Suite();
     suite.run(obj);
 };
 
 MochiKit.Test.Suite = function () {
     this.testIndex = 0;
     MochiKit.Base.bindMethods(this);
 };
 
 MochiKit.Test.Suite.prototype = {
     run: function (obj) {
         try {
             obj(this);
         } catch (e) {
             this.traceback(e);
         }
     },
     traceback: function (e) {
         var items = MochiKit.Iter.sorted(MochiKit.Base.items(e));
         print("not ok " + this.testIndex + " - Error thrown");
         for (var i = 0; i < items.length; i++) {
             var kv = items[i];
             if (kv[0] == "stack") {
                 kv[1] = kv[1].split(/\n/)[0];
             }
             this.print("# " + kv.join(": "));
         }
     },
     print: function (s) {
         print(s);
     },
     is: function (got, expected, /* optional */message) {
         var res = 1;
         var msg = null;
         try {
             res = MochiKit.Base.compare(got, expected);
         } catch (e) {
             msg = "Can not compare " + typeof(got) + ":" + typeof(expected);
         }
         if (res) {
             msg = "Expected value did not compare equal";
         }
         if (!res) {
             return this.testResult(true, message);
         }
         return this.testResult(false, message,
             [[msg], ["got:", got], ["expected:", expected]]);
     },
 
     testResult: function (pass, msg, failures) {
         this.testIndex += 1;
         if (pass) {
             this.print("ok " + this.testIndex + " - " + msg);
             return;
         }
         this.print("not ok " + this.testIndex + " - " + msg);
         if (failures) {
             for (var i = 0; i < failures.length; i++) {
diff --git a/frontend/gamma/js/MochiKit/Text.js b/frontend/gamma/js/MochiKit/Text.js
index a44f7e4..ff6366d 100644
--- a/frontend/gamma/js/MochiKit/Text.js
+++ b/frontend/gamma/js/MochiKit/Text.js
@@ -1,577 +1,546 @@
 /***
 
 MochiKit.Text 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2008 Per Cederberg.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Text', '1.5', ['Base', 'Format']);
+MochiKit.Base.module(MochiKit, 'Text', '1.5', ['Base', 'Format']);
 
 /**
  * Checks if a text string starts with the specified substring. If
  * either of the two strings is null, false will be returned.
  *
  * @param {String} substr the substring to search for
  * @param {String} str the string to search in
  *
  * @return {Boolean} true if the string starts with the substring, or
  *         false otherwise
  */
 MochiKit.Text.startsWith = function (substr, str) {
     return str != null && substr != null && str.indexOf(substr) == 0;
-}
+};
 
 /**
  * Checks if a text string ends with the specified substring. If
  * either of the two strings is null, false will be returned.
  *
  * @param {String} substr the substring to search for
  * @param {String} str the string to search in
  *
  * @return {Boolean} true if the string ends with the substring, or
  *         false otherwise
  */
 MochiKit.Text.endsWith = function (substr, str) {
     return str != null && substr != null &&
            str.lastIndexOf(substr) == Math.max(str.length - substr.length, 0);
-}
+};
 
 /**
  * Checks if a text string contains the specified substring. If
  * either of the two strings is null, false will be returned.
  *
  * @param {String} substr the substring to search for
  * @param {String} str the string to search in
  *
  * @return {Boolean} true if the string contains the substring, or
  *         false otherwise
  */
 MochiKit.Text.contains = function (substr, str) {
     return str != null && substr != null && str.indexOf(substr) >= 0;
-}
+};
 
 /**
  * Adds a character to the left-hand side of a string until it
  * reaches the specified minimum length.
  *
  * @param {String} str the string to process
  * @param {Number} minLength the requested minimum length
  * @param {String} fillChar the padding character to add, defaults
  *            to a space
  *
  * @return {String} the padded string
  */
 MochiKit.Text.padLeft = function (str, minLength, fillChar) {
     str = str || "";
     fillChar = fillChar || " ";
     while (str.length < minLength) {
         str = fillChar + str;
     }
     return str;
-}
+};
 
 /**
  * Adds a character to the right-hand side of a string until it
  * reaches the specified minimum length.
  *
  * @param {String} str the string to process
  * @param {Number} minLength the requested minimum length
  * @param {String} fillChar the padding character to add, defaults
  *            to a space
  *
  * @return {String} the padded string
  */
 MochiKit.Text.padRight = function (str, minLength, fillChar) {
     str = str || "";
     fillChar = fillChar || " ";
     while (str.length < minLength) {
         str += fillChar;
     }
     return str;
-}
+};
 
 /**
  * Returns a truncated copy of a string. If the string is shorter
  * than the specified maximum length, the object will be returned
  * unmodified. If an optional tail string is specified, additional
  * elements will be removed in order to accomodate the tail (that
  * will be appended). This function also works on arrays.
  *
  * @param {String} str the string to truncate
  * @param {Number} maxLength the maximum length
  * @param {String} [tail] the tail to append on truncation
  *
  * @return {String} the truncated string
  */
 MochiKit.Text.truncate = function (str, maxLength, tail) {
     if (str == null || str.length <= maxLength || maxLength < 0) {
         return str;
     } else if (tail != null) {
         str = str.slice(0, Math.max(0, maxLength - tail.length));
         if (typeof(str) == "string") {
             return str + tail;
         } else {
             return MochiKit.Base.extend(str, tail);
         }
     } else {
         return str.slice(0, maxLength);
     }
-}
+};
 
 /**
- * Splits a text string, applies a function and joins the results
- * back together again. This is a convenience function for calling
- * split(), map() and join() separately. It can be used to easily
- * trim each line in a text string (using the strip function), or to
- * translate a text word-by-word.
+ * Splits a text string using separator as the split point
+ * If max is given, at most max splits are done, giving at most
+ * max + 1 elements in the returned list.
  *
- * @param {Function} func the function to apply
  * @param {String} str the string to split
- * @param {String} [separator] the separator character to use,
+ * @param {String/RegExp} [separator] the separator char or regexp to use,
  *            defaults to newline
+ * @param {Number} [max] the maximum number of parts to return
+ * @return {Array} an array of parts of the string
+ */
+MochiKit.Text.split = function (str, separator, max) {
+    if (str == null) {
+        return str;
+    }
+    separator = separator || '\n';
+    var bits = str.split(separator);
+    if ((typeof(max) == "undefined") || max >= bits.length - 1) {
+        return bits;
+    }
+    bits.splice(max, bits.length, bits.slice(max, bits.length).join(separator));
+    return bits;
+};
+
+/**
+ * Splits a text string using separator as the split point
+ * If max is given, at most max splits are done,
+ * using splits from the right
  *
- * @return {String} a string with the joined up results
+ * @param {String} str the string to split
+ * @param {String/RegExp} [separator] the separator char or regexp to use,
+ *            defaults to newline
+ * @param {Number} [max] the maximum number of parts to return
+ * @return {Array} an array of parts of the string
  */
-MochiKit.Text.splitJoin = function (func, str, separator) {
-    if (str == null || str.length == 0) {
+MochiKit.Text.rsplit = function (str, separator, max) {
+    if (str == null) {
         return str;
     }
-    separator = separator || '\n'
-    return MochiKit.Base.map(func, str.split(separator)).join(separator);
-}
+    separator = separator || '\n';
+    var bits = str.split(separator);
+    if ((typeof(max) == "undefined") || max >= bits.length - 1){
+        return bits;
+    }
+    bits.splice(0, bits.length-max, bits.slice(0, bits.length-max).join(separator));
+    return bits;
+};
 
 /**
  * Creates a formatter function for the specified formatter pattern
  * and locale. The returned function takes as many arguments as the
  * formatter pattern requires. See separate documentation for
  * information about the formatter pattern syntax.
  *
  * @param {String} pattern the formatter pattern string
  * @param {Object} [locale] the locale to use, defaults to
  *            LOCALE.en_US
  *
  * @return {Function} the formatter function created
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text.formatter = function (pattern, locale) {
-    if (typeof(locale) == "undefined") {
+    if (locale == null) {
         locale = MochiKit.Format.formatLocale();
     } else if (typeof(locale) == "string") {
         locale = MochiKit.Format.formatLocale(locale);
     }
     var parts = MochiKit.Text._parsePattern(pattern);
     return function() {
         var values = MochiKit.Base.extend([], arguments);
         var res = [];
         for (var i = 0; i < parts.length; i++) {
             if (typeof(parts[i]) == "string") {
                 res.push(parts[i]);
             } else {
                 res.push(MochiKit.Text.formatValue(parts[i], values, locale));
             }
         }
         return res.join("");
-    }
-}
+    };
+};
 
 /**
  * Formats the specified arguments according to a formatter pattern.
  * See separate documentation for information about the formatter
  * pattern syntax.
  *
  * @param {String} pattern the formatter pattern string
  * @param {Object} [...] the optional values to format
  *
  * @return {String} the formatted output string
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text.format = function (pattern/*, ...*/) {
     var func = MochiKit.Text.formatter(pattern);
     return func.apply(this, MochiKit.Base.extend([], arguments, 1));
-}
+};
 
 /**
  * Format a value with the specified format specifier.
  *
  * @param {String/Object} spec the format specifier string or parsed
  *            format specifier object
  * @param {Object} value the value to format
  * @param {Object} [locale] the locale to use, defaults to
  *            LOCALE.en_US
  *
  * @return {String} the formatted output string
+ *
+ * @throws FormatPatternError if the format specifier was invalid
  */
 MochiKit.Text.formatValue = function (spec, value, locale) {
     var self = MochiKit.Text;
     if (typeof(spec) === "string") {
-        spec = self._parseFormatFlags(spec, 0, spec.length - 1);
+        spec = self._parseFormatFlags(spec, 0, spec.length);
     }
     for (var i = 0; spec.path != null && i < spec.path.length; i++) {
         if (value != null) {
             value = value[spec.path[i]];
         }
     }
-    if (typeof(locale) == "undefined") {
+    if (locale == null) {
         locale = MochiKit.Format.formatLocale();
     } else if (typeof(locale) == "string") {
         locale = MochiKit.Format.formatLocale(locale);
     }
     var str = "";
-    if (spec.numeric) {
+    if (spec.type == "number") {
+        if (value instanceof Number) {
+            value = value.valueOf();
+        }
         if (typeof(value) != "number" || isNaN(value)) {
             str = "";
         } else if (value === Number.POSITIVE_INFINITY) {
             str = "\u221e";
         } else if (value === Number.NEGATIVE_INFINITY) {
             str = "-\u221e";
         } else {
-            var sign = (spec.sign === "-") ? "" : spec.sign;
-            sign = (value < 0) ? "-" : sign;
+            var sign = (value < 0) ? "-" : spec.sign;
             value = Math.abs(value);
             if (spec.format === "%") {
                 str = self._truncToPercent(value, spec.precision);
             } else if (spec.format === "d") {
                 str = MochiKit.Format.roundToFixed(value, 0);
             } else if (spec.radix != 10) {
                 str = Math.floor(value).toString(spec.radix);
                 if (spec.format === "x") {
                     str = str.toLowerCase();
                 } else if (spec.format === "X") {
                     str = str.toUpperCase();
                 }
             } else if (spec.precision >= 0) {
                 str = MochiKit.Format.roundToFixed(value, spec.precision);
             } else {
                 str = value.toString();
             }
             if (spec.padding === "0" && spec.format === "%") {
                 str = self.padLeft(str, spec.width - sign.length - 1, "0");
             } else if (spec.padding == "0") {
                 str = self.padLeft(str, spec.width - sign.length, "0");
             }
-            str = self._localizeNumber(str, locale, spec.grouping);
+            str = self._localizeNumber(str, locale, spec.group);
             str = sign + str;
         }
         if (str !== "" && spec.format === "%") {
             str = str + locale.percent;
         }
     } else {
         if (spec.format == "r") {
             str = MochiKit.Base.repr(value);
         } else {
-            str = (value == null) ? "null" : value.toString();
+            str = (value == null) ? "" : value.toString();
         }
         str = self.truncate(str, spec.precision);
     }
     if (spec.align == "<") {
         str = self.padRight(str, spec.width);
     } else {
         str = self.padLeft(str, spec.width);
     }
     return str;
-}
+};
 
 /**
  * Adjust an already formatted numeric string for locale-specific
  * grouping and decimal separators. The grouping is optional and
  * will attempt to keep the number string length intact by removing
  * padded zeros (if possible).
  *
  * @param {String} num the formatted number string
  * @param {Object} locale the formatting locale to use
- * @param {Boolean} grouping the grouping flag
+ * @param {Boolean} group the grouping flag
  *
  * @return {String} the localized number string
  */
-MochiKit.Text._localizeNumber = function (num, locale, grouping) {
+MochiKit.Text._localizeNumber = function (num, locale, group) {
     var parts = num.split(/\./);
     var whole = parts[0];
     var frac = (parts.length == 1) ? "" : parts[1];
     var res = (frac.length > 0) ? locale.decimal : "";
-    while (grouping && frac.length > 3) {
+    while (group && frac.length > 3) {
         res = res + frac.substring(0, 3) + locale.separator;
         frac = frac.substring(3);
         if (whole.charAt(0) == "0") {
             whole = whole.substring(1);
         }
     }
     if (frac.length > 0) {
-        res += frac;
+        res = res + frac;
     }
-    while (grouping && whole.length > 3) {
+    while (group && whole.length > 3) {
         var pos = whole.length - 3;
         res = locale.separator + whole.substring(pos) + res;
         whole = whole.substring((whole.charAt(0) == "0") ? 1 : 0, pos);
     }
     return whole + res;
-}
+};
 
 /**
  * Parses a format pattern and returns an array of constant strings
  * and format info objects.
  *
  * @param {String} pattern the format pattern to analyze
  *
  * @return {Array} an array of strings and format info objects
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text._parsePattern = function (pattern) {
     var self = MochiKit.Text;
     var parts = [];
-    var start = 0;
-    var pos = 0;
-    for (pos = 0; pos < pattern.length; pos++) {
-        if (pattern.charAt(pos) == "{") {
-            if (pos + 1 >= pattern.length) {
-                var msg = "unescaped { char, should be escaped as {{";
-                throw new self.FormatPatternError(pattern, pos, msg);
-            } else if (pattern.charAt(pos + 1) == "{") {
-                parts.push(pattern.substring(start, pos + 1));
-                start = pos + 2;
-                pos++;
-            } else {
-                if (start < pos) {
-                    parts.push(pattern.substring(start, pos));
-                }
-                start = pattern.indexOf("}", pos) + 1;
-                if (start <= 0) {
-                    var msg = "unmatched { char, not followed by a } char";
-                    throw new self.FormatPatternError(pattern, pos, msg);
-                }
-                parts.push(self._parseFormat(pattern, pos + 1, start - 1));
-                pos = start - 1;
-            }
-        } else if (pattern.charAt(pos) == "}") {
-            if (pos + 1 >= pattern.length || pattern.charAt(pos + 1) != "}") {
-                var msg = "unescaped } char, should be escaped as }}";
-                throw new self.FormatPatternError(pattern, pos, msg);
-            }
-            parts.push(pattern.substring(start, pos + 1));
-            start = pos + 2;
-            pos++;
+    var re = /{[^{}]*}|{{?|}}?/g;
+    var lastPos = re.lastIndex = 0;
+    var m;
+    while ((m = re.exec(pattern)) != null) {
+        if (lastPos < m.index) {
+            parts.push(pattern.substring(lastPos, m.index))
+        }
+        var str = m[0];
+        lastPos = m.index + str.length;
+        if (self.startsWith("{", str) && self.endsWith("}", str)) {
+            parts.push(self._parseFormat(pattern, m.index + 1, lastPos - 1));
+        } else if (self.startsWith("{{", str) || self.startsWith("}}", str)) {
+            parts.push(str.substring(1));
+        } else if (self.startsWith("{", str)) {
+            var msg = "unescaped { char, should be escaped as {{";
+            throw new self.FormatPatternError(pattern, m.index, msg);
+        } else if (self.startsWith("}", str)) {
+            var msg = "unescaped } char, should be escaped as }}";
+            throw new self.FormatPatternError(pattern, m.index, msg);
         }
     }
-    if (start < pos) {
-        parts.push(pattern.substring(start, pos));
+    if (lastPos < pattern.length) {
+        parts.push(pattern.substring(lastPos));
     }
     return parts;
-}
+};
 
 /**
  * Parses a format instruction and returns a format info object.
  *
  * @param {String} pattern the format pattern string
  * @param {Number} startPos the first index of the format instruction
  * @param {Number} endPos the last index of the format instruction
  *
  * @return {Object} the format info object
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text._parseFormat = function (pattern, startPos, endPos) {
     var self = MochiKit.Text;
     var text = pattern.substring(startPos, endPos);
-    var info;
-    var pos = text.indexOf(":");
-    if (pos == 0) {
-        info = self._parseFormatFlags(pattern, startPos + 1, endPos);
-        info.path = [0];
-    } else if (pos > 0) {
-        info = self._parseFormatFlags(pattern, startPos + pos + 1, endPos);
-        info.path = text.substring(0, pos).split(".");
-    } else {
-        info = self._parseFormatFlags(pattern, endPos, endPos);
-        info.path = text.split(".");
-    }
-    var DIGITS = /^\d+$/;
+    var parts = self.split(text, ":", 1);
+    var path = parts[0];
+    var flagsPos = startPos + path.length + ((parts.length == 1) ? 0 : 1);
+    var info = self._parseFormatFlags(pattern, flagsPos, endPos);
+    info.path = (path == "") ? [] : path.split(".");
     for (var i = 0; i < info.path.length; i++) {
-        var e = info.path[i];
-        if (typeof(e) == "string") {
-            // TODO: replace with MochiKit.Format.strip?
-            e = e.replace(/^\s+/, "").replace(/\s+$/, "");
-            if (e == "" && info.path.length == 1) {
-                e = 0;
-            } else if (e == "") {
-                var msg = "format value path contains blanks";
-                throw new self.FormatPatternError(pattern, startPos, msg);
-            } else if (DIGITS.test(e)) {
-                e = parseInt(e);
-            }
+        var v = info.path[i];
+        // TODO: replace with MochiKit.Format.strip?
+        v = v.replace(/^\s+/, "").replace(/\s+$/, "");
+        if (v == "" && info.path.length == 1) {
+            v = 0;
+        } else if (v == "") {
+            var msg = "format value path contains blanks";
+            throw new self.FormatPatternError(pattern, startPos, msg);
+        } else if (/^\d+$/.test(v)) {
+            v = parseInt(v, 10);
         }
-        info.path[i] = e;
+        info.path[i] = v;
     }
-    if (info.path.length < 0 || typeof(info.path[0]) != "number") {
+    if (info.path.length <= 0 || typeof(info.path[0]) != "number") {
         info.path.unshift(0);
     }
     return info;
-}
+};
 
 /**
  * Parses a string with format flags and returns a format info object.
  *
  * @param {String} pattern the format pattern string
  * @param {Number} startPos the first index of the format instruction
  * @param {Number} endPos the last index of the format instruction
  *
  * @return {Object} the format info object
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text._parseFormatFlags = function (pattern, startPos, endPos) {
-    var self = MochiKit.Text;
-    var info = { numeric: false, format: "s", width: 0, precision: -1,
-                 align: ">", sign: "-", padding: " ", grouping: false };
+    var update = MochiKit.Base.update;
+    var info = { type: "string", format: "s", width: 0, precision: -1,
+                 align: ">", sign: "", padding: " ", group: false };
     // TODO: replace with MochiKit.Format.rstrip?
-    var flags = pattern.substring(startPos, endPos).replace(/\s+$/, "");
-    while (flags.length > 0) {
-        switch (flags.charAt(0)) {
-        case ">":
-        case "<":
-            info.align = flags.charAt(0);
-            flags = flags.substring(1);
-            break;
-        case "+":
-        case "-":
-        case " ":
-            info.sign = flags.charAt(0);
-            flags = flags.substring(1);
-            break;
-        case ",":
-            info.grouping = true;
-            flags = flags.substring(1);
-            break;
-        case ".":
-            var chars = /^\d*/.exec(flags.substring(1))[0];
-            info.precision = parseInt(chars);
-            flags = flags.substring(1 + chars.length);
-            break;
-        case "0":
-            info.padding = flags.charAt(0);
-            flags = flags.substring(1);
-            break;
-        case "1":
-        case "2":
-        case "3":
-        case "4":
-        case "5":
-        case "6":
-        case "7":
-        case "8":
-        case "9":
-            var chars = /^\d*/.exec(flags)[0];
-            info.width = parseInt(chars);
-            flags = flags.substring(chars.length);
-            break;
-        case "s":
-        case "r":
-            info.format = flags.charAt(0);
-            flags = flags.substring(1);
-            break;
-        case "b":
-        case "d":
-        case "o":
-        case "x":
-        case "X":
-        case "f":
-        case "%":
-            info.numeric = true;
-            info.format = flags.charAt(0);
-            info.radix = 10;
-            if (info.format === "b") {
-                info.radix = 2;
-            } else if (info.format === "o") {
-                info.radix = 8;
-            } else if (info.format === "x" || info.format === "X") {
-                info.radix = 16;
-            }
-            flags = flags.substring(1);
-            break;
-        default:
-            var msg = "unsupported format flag: " + flags.charAt(0);
-            throw new self.FormatPatternError(pattern, startPos, msg);
+    var text = pattern.substring(startPos, endPos).replace(/\s+$/, "");
+    var m = /^([<>+ 0,-]+)?(\d+)?(\.\d*)?([srbdoxXf%])?(.*)$/.exec(text);
+    var flags = m[1];
+    var width = m[2];
+    var precision = m[3];
+    var type = m[4];
+    var unmatched = m[5];
+    for (var i = 0; flags && i < flags.length; i++) {
+        var chr = flags.charAt(i);
+        if (chr == "<" || chr == ">") {
+            info.align = chr;
+        } else if (chr == "+" || chr == "-" || chr == " ") {
+            info.sign = (chr == "-") ? "" : chr;
+        } else if (chr == "0") {
+            info.padding = chr;
+        } else if (chr == ",") {
+            info.group = true;
         }
     }
+    if (width) {
+        info.width = parseInt(width, 10);
+    }
+    if (precision && precision.length > 1) {
+        info.precision = parseInt(precision.substring(1), 10);
+    }
+    if (type == "s" || type == "r") {
+        info.format = type;
+    } else if (type == "b") {
+        update(info, { type: "number", format: type, radix: 2 });
+    } else if (type == "o") {
+        update(info, { type: "number", format: type, radix: 8 });
+    } else if (type == "x" || type == "X") {
+        update(info, { type: "number", format: type, radix: 16 });
+    } else if (type == "d" || type == "f" || type == "%") {
+        update(info, { type: "number", format: type, radix: 10 });
+    }
+    if (unmatched) {
+        var msg = "unsupported format flag: " + unmatched.charAt(0);
+        throw new MochiKit.Text.FormatPatternError(pattern, startPos, msg);
+    }
     return info;
-}
+};
 
 /**
  * Formats a value as a percentage. This method avoids multiplication
  * by 100 since it leads to weird numeric rounding errors. Instead it
  * just move the decimal separator in the text string. It is ugly,
  * but works...
  *
  * @param {Number} value the value to format
  * @param {Number} precision the number of precision digits
  */
 MochiKit.Text._truncToPercent = function (value, precision) {
-    // TODO: This can be simplified by using the same helper function
-    //       as roundToFixed now does.
+    // TODO: This can be simplified by using MochiKit.Format._shiftNumber
+    //       as roundToFixed does.
     var str;
     if (precision >= 0) {
         str = MochiKit.Format.roundToFixed(value, precision + 2);
     } else {
         str = (value == null) ? "0" : value.toString();
     }
-    var fracPos = str.indexOf(".");
-    if (fracPos < 0) {
-        str = str + "00";
-    } else if (fracPos + 3 >= str.length) {
-        var fraction = str.substring(fracPos + 1);
-        while (fraction.length < 2) {
-            fraction = fraction + "0";
-        }
-        str = str.substring(0, fracPos) + fraction;
-    } else {
-        var fraction = str.substring(fracPos + 1);
-        str = str.substring(0, fracPos) + fraction.substring(0, 2) +
-              "." + fraction.substring(2);
-    }
-    while (str.length > 1 && str.charAt(0) == "0" && str.charAt(1) != ".") {
-        str = str.substring(1);
+    var arr = MochiKit.Text.split(str, ".", 2);
+    var frac = MochiKit.Text.padRight(arr[1], 2, "0");
+    var whole = arr[0] + frac.substring(0, 2);
+    frac = frac.substring(2);
+    while (/^0[0-9]/.test(whole)) {
+        whole = whole.substring(1);
     }
-    return str;
-}
+    return (frac.length <= 0) ? whole : whole + "." + frac;
+};
 
 /**
  * Creates a new format pattern error.
  *
  * @param {String} pattern the format pattern string
  * @param {Number} pos the position of the error
  * @param {String} message the error message text
  *
  * @return {Error} the format pattern error
  *
  * @class The format pattern error class. This error is thrown when
  *     a syntax error is encountered inside a format string.
  * @property {String} pattern The format pattern string.
  * @property {Number} pos The position of the error.
  * @property {String} message The error message text.
  * @extends MochiKit.Base.NamedError
  */
 MochiKit.Text.FormatPatternError = function (pattern, pos, message) {
     this.pattern = pattern;
     this.pos = pos;
     this.message = message;
-}
-MochiKit.Text.FormatPatternError.prototype =
-    new MochiKit.Base.NamedError("MochiKit.Text.FormatPatternError");
+};
 
+MochiKit.Text.FormatPatternError.prototype = new MochiKit.Base.NamedError("MochiKit.Text.FormatPatternError");
+MochiKit.Text.FormatPatternError.constructor = MochiKit.Text.FormatPatternError;
 
 //
-//XXX: Internet Explorer exception handling blows
+//XXX: Internet Explorer export fix
 //
 if (MochiKit.__export__) {
     formatter = MochiKit.Text.formatter;
     format = MochiKit.Text.format;
     formatValue = MochiKit.Text.formatValue;
 }
 
 
 MochiKit.Base.nameFunctions(MochiKit.Text);
 MochiKit.Base._exportSymbols(this, MochiKit.Text);
diff --git a/frontend/gamma/js/MochiKit/Visual.js b/frontend/gamma/js/MochiKit/Visual.js
index 648d82a..372d99a 100644
--- a/frontend/gamma/js/MochiKit/Visual.js
+++ b/frontend/gamma/js/MochiKit/Visual.js
@@ -1,75 +1,75 @@
 /***
 
 MochiKit.Visual 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito and others.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Visual', '1.5', ['Base', 'DOM', 'Style', 'Color', 'Position']);
+MochiKit.Base.module(MochiKit, 'Visual', '1.5', ['Base', 'DOM', 'Style', 'Color', 'Position']);
 
 MochiKit.Visual._RoundCorners = function (e, options) {
     e = MochiKit.DOM.getElement(e);
     this._setOptions(options);
     if (this.options.__unstable__wrapElement) {
         e = this._doWrap(e);
     }
 
     var color = this.options.color;
     var C = MochiKit.Color.Color;
     if (this.options.color === "fromElement") {
         color = C.fromBackground(e);
     } else if (!(color instanceof C)) {
         color = C.fromString(color);
     }
     this.isTransparent = (color.asRGB().a <= 0);
 
     var bgColor = this.options.bgColor;
     if (this.options.bgColor === "fromParent") {
         bgColor = C.fromBackground(e.offsetParent);
     } else if (!(bgColor instanceof C)) {
         bgColor = C.fromString(bgColor);
     }
 
     this._roundCornersImpl(e, color, bgColor);
 };
 
 MochiKit.Visual._RoundCorners.prototype = {
     _doWrap: function (e) {
         var parent = e.parentNode;
         var doc = MochiKit.DOM.currentDocument();
         if (typeof(doc.defaultView) === "undefined"
             || doc.defaultView === null) {
             return e;
         }
         var style = doc.defaultView.getComputedStyle(e, null);
         if (typeof(style) === "undefined" || style === null) {
             return e;
         }
         var wrapper = MochiKit.DOM.DIV({"style": {
             display: "block",
             // convert padding to margin
             marginTop: style.getPropertyValue("padding-top"),
             marginRight: style.getPropertyValue("padding-right"),
             marginBottom: style.getPropertyValue("padding-bottom"),
             marginLeft: style.getPropertyValue("padding-left"),
             // remove padding so the rounding looks right
             padding: "0px"
             /*
             paddingRight: "0px",
             paddingLeft: "0px"
             */
         }});
         wrapper.innerHTML = e.innerHTML;
         e.innerHTML = "";
         e.appendChild(wrapper);
         return e;
     },
 
     _roundCornersImpl: function (e, color, bgColor) {
         if (this.options.border) {
             this._renderBorder(e, bgColor);
         }
         if (this._isTopRounded()) {
@@ -408,323 +408,337 @@ MochiKit.Visual.toggle = function (element, /* optional */effect, /* optional */
     Toggle an item between two state depending of its visibility, making
     a effect between these states. Default  effect is 'appear', can be
     'slide' or 'blind'.
 
     ***/
     element = MochiKit.DOM.getElement(element);
     effect = (effect || 'appear').toLowerCase();
     options = MochiKit.Base.update({
         queue: {position: 'end', scope: (element.id || 'global'), limit: 1}
     }, options);
     var v = MochiKit.Visual;
     v[MochiKit.Style.getStyle(element, 'display') != 'none' ?
       v.PAIRS[effect][1] : v.PAIRS[effect][0]](element, options);
 };
 
 /***
 
 Transitions: define functions calculating variations depending of a position.
 
 ***/
 
 MochiKit.Visual.Transitions = { __export__: false };
 
 /** @id MochiKit.Visual.Transitions.linear */
 MochiKit.Visual.Transitions.linear = function (pos) {
     return pos;
 };
 
 /** @id MochiKit.Visual.Transitions.sinoidal */
 MochiKit.Visual.Transitions.sinoidal = function (pos) {
     return 0.5 - Math.cos(pos*Math.PI)/2;
 };
 
 /** @id MochiKit.Visual.Transitions.reverse */
 MochiKit.Visual.Transitions.reverse = function (pos) {
     return 1 - pos;
 };
 
 /** @id MochiKit.Visual.Transitions.flicker */
 MochiKit.Visual.Transitions.flicker = function (pos) {
     return 0.25 - Math.cos(pos*Math.PI)/4 + Math.random()/2;
 };
 
 /** @id MochiKit.Visual.Transitions.wobble */
 MochiKit.Visual.Transitions.wobble = function (pos) {
     return 0.5 - Math.cos(9*pos*Math.PI)/2;
 };
 
 /** @id MochiKit.Visual.Transitions.pulse */
 MochiKit.Visual.Transitions.pulse = function (pos, pulses) {
     if (pulses) {
         pos *= 2 * pulses;
     } else {
         pos *= 10;
     }
     var decimals = pos - Math.floor(pos);
     return (Math.floor(pos) % 2 == 0) ? decimals : 1 - decimals;
 };
 
 /** @id MochiKit.Visual.Transitions.parabolic */
 MochiKit.Visual.Transitions.parabolic = function (pos) {
    return pos * pos;
 };
 
+/** @id MochiKit.Visual.Transitions.spring */
+MochiKit.Visual.Transitions.spring = function (pos) {
+   return 1 - (Math.cos(pos * 2.5 * Math.PI) * Math.exp(-pos * 6));
+};
+
 /** @id MochiKit.Visual.Transitions.none */
 MochiKit.Visual.Transitions.none = function (pos) {
     return 0;
 };
 
 /** @id MochiKit.Visual.Transitions.full */
 MochiKit.Visual.Transitions.full = function (pos) {
     return 1;
 };
 
 /***
 
 Core effects
 
 ***/
 
 MochiKit.Visual.ScopedQueue = function () {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls();
     }
     this.__init__();
 };
 MochiKit.Visual.ScopedQueue.__export__ = false;
 
 MochiKit.Base.update(MochiKit.Visual.ScopedQueue.prototype, {
     __init__: function () {
         this.effects = [];
         this.interval = null;
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.add */
     add: function (effect) {
         var timestamp = new Date().getTime();
 
         var position = (typeof(effect.options.queue) == 'string') ?
             effect.options.queue : effect.options.queue.position;
 
         var ma = MochiKit.Base.map;
         switch (position) {
             case 'front':
                 // move unstarted effects after this effect
                 ma(function (e) {
                     if (e.state == 'idle') {
                         e.startOn += effect.finishOn;
                         e.finishOn += effect.finishOn;
                     }
                 }, this.effects);
                 break;
             case 'end':
                 var finish;
                 // start effect after last queued effect has finished
                 ma(function (e) {
                     var i = e.finishOn;
                     if (i >= (finish || i)) {
                         finish = i;
                     }
                 }, this.effects);
                 timestamp = finish || timestamp;
                 break;
             case 'break':
                 ma(function (e) {
                     e.finalize();
                 }, this.effects);
                 break;
+            case 'replace':
+                ma(function (e) {
+                    e.cancel();
+                }, this.effects);
+                break;
         }
 
         effect.startOn += timestamp;
         effect.finishOn += timestamp;
         if (!effect.options.queue.limit ||
             this.effects.length < effect.options.queue.limit) {
             this.effects.push(effect);
         }
 
         if (!this.interval) {
             this.interval = this.startLoop(MochiKit.Base.bind(this.loop, this),
                                         40);
         }
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.startLoop */
     startLoop: function (func, interval) {
         return setInterval(func, interval);
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.remove */
     remove: function (effect) {
         this.effects = MochiKit.Base.filter(function (e) {
             return e != effect;
         }, this.effects);
         if (!this.effects.length) {
             this.stopLoop(this.interval);
             this.interval = null;
         }
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.stopLoop */
     stopLoop: function (interval) {
         clearInterval(interval);
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.loop */
     loop: function () {
         var timePos = new Date().getTime();
         MochiKit.Base.map(function (effect) {
             effect.loop(timePos);
         }, this.effects);
     }
 });
 
 MochiKit.Visual.Queues = {
     __export__: false,
     instances: {},
     get: function (queueName) {
         if (typeof(queueName) != 'string') {
             return queueName;
         }
 
         if (!this.instances[queueName]) {
             this.instances[queueName] = new MochiKit.Visual.ScopedQueue();
         }
         return this.instances[queueName];
     }
 };
 
 MochiKit.Visual.Queue = MochiKit.Visual.Queues.get('global');
 MochiKit.Visual.Queue.__export__ = false;
 
 MochiKit.Visual.DefaultOptions = {
     __export__: false,
     transition: MochiKit.Visual.Transitions.sinoidal,
     duration: 1.0,  // seconds
     fps: 25.0,  // max. 25fps due to MochiKit.Visual.Queue implementation
     sync: false,  // true for combining
     from: 0.0,
     to: 1.0,
     delay: 0.0,
     queue: 'parallel'
 };
 
 MochiKit.Visual.Base = function () {};
 
 MochiKit.Visual.Base.prototype = {
     /***
 
     Basic class for all Effects. Define a looping mechanism called for each step
     of an effect. Don't instantiate it, only subclass it.
 
     ***/
 
     __class__ : MochiKit.Visual.Base,
 
     /** @id MochiKit.Visual.Base.prototype.start */
     start: function (options) {
         var v = MochiKit.Visual;
         this.options = MochiKit.Base.setdefault(options,
                                                 v.DefaultOptions);
         this.currentFrame = 0;
         this.state = 'idle';
         this.startOn = this.options.delay*1000;
         this.finishOn = this.startOn + (this.options.duration*1000);
         this.event('beforeStart');
         if (!this.options.sync) {
             v.Queues.get(typeof(this.options.queue) == 'string' ?
                 'global' : this.options.queue.scope).add(this);
         }
     },
 
     /** @id MochiKit.Visual.Base.prototype.loop */
     loop: function (timePos) {
         if (timePos >= this.startOn) {
             if (timePos >= this.finishOn) {
                 return this.finalize();
             }
             var pos = (timePos - this.startOn) / (this.finishOn - this.startOn);
             var frame =
                 Math.round(pos * this.options.fps * this.options.duration);
             if (frame > this.currentFrame) {
                 this.render(pos);
                 this.currentFrame = frame;
             }
         }
     },
 
     /** @id MochiKit.Visual.Base.prototype.render */
     render: function (pos) {
         if (this.state == 'idle') {
             this.state = 'running';
             this.event('beforeSetup');
             this.setup();
             this.event('afterSetup');
         }
         if (this.state == 'running') {
-            if (this.options.transition) {
-                pos = this.options.transition(pos);
+            var trans = this.options.transition;
+            if (typeof(trans) == "string") {
+                trans = MochiKit.Visual.Transitions[trans];
+            }
+            if (typeof(trans) == "function") {
+                pos = trans(pos);
             }
             pos *= (this.options.to - this.options.from);
             pos += this.options.from;
             this.event('beforeUpdate');
             this.update(pos);
             this.event('afterUpdate');
         }
     },
 
     /** @id MochiKit.Visual.Base.prototype.cancel */
     cancel: function () {
         if (!this.options.sync) {
             MochiKit.Visual.Queues.get(typeof(this.options.queue) == 'string' ?
                 'global' : this.options.queue.scope).remove(this);
         }
         this.state = 'finished';
     },
 
     /** @id MochiKit.Visual.Base.prototype.finalize */
     finalize: function () {
         this.render(1.0);
         this.cancel();
         this.event('beforeFinish');
         this.finish();
         this.event('afterFinish');
     },
 
     setup: function () {
     },
 
     finish: function () {
     },
 
     update: function (position) {
     },
 
     /** @id MochiKit.Visual.Base.prototype.event */
     event: function (eventName) {
         if (this.options[eventName + 'Internal']) {
             this.options[eventName + 'Internal'](this);
         }
         if (this.options[eventName]) {
             this.options[eventName](this);
         }
     },
 
     /** @id MochiKit.Visual.Base.prototype.repr */
     repr: function () {
         return '[' + this.__class__.NAME + ', options:' +
                MochiKit.Base.repr(this.options) + ']';
     }
 };
 
 /** @id MochiKit.Visual.Parallel */
 MochiKit.Visual.Parallel = function (effects, options) {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls(effects, options);
     }
 
     this.__init__(effects, options);
 };
 
 MochiKit.Visual.Parallel.prototype = new MochiKit.Visual.Base();
@@ -1625,130 +1639,130 @@ MochiKit.Visual.slideUp = function (element, /* optional */ options) {
     Slide an element up.
     It needs to have the content of the element wrapped in a container
     element with fixed height.
 
     ***/
     var d = MochiKit.DOM;
     var b = MochiKit.Base;
     var s = MochiKit.Style;
     element = d.getElement(element);
     if (!element.firstChild) {
         throw new Error("MochiKit.Visual.slideUp must be used on a element with a child");
     }
     d.removeEmptyTextNodes(element);
     var oldInnerBottom = s.getStyle(element.firstChild, 'bottom');
     var elementDimensions = s.getElementDimensions(element, true);
     var elemClip;
     options = b.update({
         scaleContent: false,
         scaleX: false,
         scaleMode: {originalHeight: elementDimensions.h,
                     originalWidth: elementDimensions.w},
         scaleFrom: 100,
         restoreAfterFinish: true,
         beforeStartInternal: function (effect) {
             s.makePositioned(effect.element);
             s.makePositioned(effect.element.firstChild);
             if (/Opera/.test(navigator.userAgent)) {
                 s.setStyle(effect.element, {top: ''});
             }
             elemClip = s.makeClipping(effect.element);
             s.showElement(effect.element);
         },
         afterUpdateInternal: function (effect) {
             var elementDimensions = s.getElementDimensions(effect.element, true);
             s.setStyle(effect.element.firstChild,
                 {bottom: (effect.dims[0] - elementDimensions.h) + 'px'});
         },
         afterFinishInternal: function (effect) {
             s.hideElement(effect.element);
             s.undoClipping(effect.element, elemClip);
             s.undoPositioned(effect.element.firstChild);
             s.undoPositioned(effect.element);
             s.setStyle(effect.element.firstChild, {bottom: oldInnerBottom});
         }
     }, options);
     return new MochiKit.Visual.Scale(element, 0, options);
 };
 
 // Bug in opera makes the TD containing this element expand for a instance
 // after finish
 /** @id MochiKit.Visual.squish */
 MochiKit.Visual.squish = function (element, /* optional */ options) {
     /***
 
     Reduce an element and make it disappear.
 
     ***/
     var d = MochiKit.DOM;
     var b = MochiKit.Base;
     var s = MochiKit.Style;
     var elementDimensions = s.getElementDimensions(element, true);
     var elemClip;
     options = b.update({
         restoreAfterFinish: true,
-        scaleMode: {originalHeight: elementDimensions.w,
-                    originalWidth: elementDimensions.h},
+        scaleMode: {originalHeight: elementDimensions.h,
+                    originalWidth: elementDimensions.w},
         beforeSetupInternal: function (effect) {
             elemClip = s.makeClipping(effect.element);
         },
         afterFinishInternal: function (effect) {
             s.hideElement(effect.element);
             s.undoClipping(effect.element, elemClip);
         }
     }, options);
 
     return new MochiKit.Visual.Scale(element, /Opera/.test(navigator.userAgent) ? 1 : 0, options);
 };
 
 /** @id MochiKit.Visual.grow */
 MochiKit.Visual.grow = function (element, /* optional */ options) {
     /***
 
     Grow an element to its original size. Make it zero-sized before
     if necessary.
 
     ***/
     var d = MochiKit.DOM;
     var v = MochiKit.Visual;
     var s = MochiKit.Style;
     element = d.getElement(element);
     options = MochiKit.Base.update({
         direction: 'center',
         moveTransition: v.Transitions.sinoidal,
         scaleTransition: v.Transitions.sinoidal,
         opacityTransition: v.Transitions.full,
         scaleContent: true,
         scaleFromCenter: false
     }, options);
     var oldStyle = {
         top: element.style.top,
         left: element.style.left,
         height: element.style.height,
         width: element.style.width,
         opacity: s.getStyle(element, 'opacity')
     };
     var dims = s.getElementDimensions(element, true);
     var initialMoveX, initialMoveY;
     var moveX, moveY;
 
     switch (options.direction) {
         case 'top-left':
             initialMoveX = initialMoveY = moveX = moveY = 0;
             break;
         case 'top-right':
             initialMoveX = dims.w;
             initialMoveY = moveY = 0;
             moveX = -dims.w;
             break;
         case 'bottom-left':
             initialMoveX = moveX = 0;
             initialMoveY = dims.h;
             moveY = -dims.h;
             break;
         case 'bottom-right':
             initialMoveX = dims.w;
             initialMoveY = dims.h;
             moveX = -dims.w;
             moveY = -dims.h;
             break;
         case 'center':
@@ -1897,79 +1911,66 @@ MochiKit.Visual.pulsate = function (element, /* optional */ options) {
 
     Pulse an element between appear/fade.
 
     ***/
     var d = MochiKit.DOM;
     var v = MochiKit.Visual;
     var b = MochiKit.Base;
     var oldOpacity = MochiKit.Style.getStyle(element, 'opacity');
     options = b.update({
         duration: 3.0,
         from: 0,
         afterFinishInternal: function (effect) {
             MochiKit.Style.setStyle(effect.element, {'opacity': oldOpacity});
         }
     }, options);
     var transition = options.transition || v.Transitions.sinoidal;
     options.transition = function (pos) {
         return transition(1 - v.Transitions.pulse(pos, options.pulses));
     };
     return new v.Opacity(element, options);
 };
 
 /** @id MochiKit.Visual.fold */
 MochiKit.Visual.fold = function (element, /* optional */ options) {
     /***
 
     Fold an element, first vertically, then horizontally.
 
     ***/
     var d = MochiKit.DOM;
     var v = MochiKit.Visual;
     var s = MochiKit.Style;
     element = d.getElement(element);
     var elementDimensions = s.getElementDimensions(element, true);
     var oldStyle = {
         top: element.style.top,
         left: element.style.left,
         width: element.style.width,
         height: element.style.height
     };
     var elemClip = s.makeClipping(element);
     options = MochiKit.Base.update({
         scaleContent: false,
         scaleX: false,
         scaleMode: {originalHeight: elementDimensions.h,
                     originalWidth: elementDimensions.w},
         afterFinishInternal: function (effect) {
             new v.Scale(element, 1, {
                 scaleContent: false,
                 scaleY: false,
                 scaleMode: {originalHeight: elementDimensions.h,
                             originalWidth: elementDimensions.w},
                 afterFinishInternal: function (effect) {
                     s.hideElement(effect.element);
                     s.undoClipping(effect.element, elemClip);
                     s.setStyle(effect.element, oldStyle);
                 }
             });
         }
     }, options);
     return new v.Scale(element, 5, options);
 };
 
 
-/* end of Rico adaptation */
-
-MochiKit.Visual.__new__ = function () {
-    var m = MochiKit.Base;
-
-    // Backwards compatibility aliases
-    m._deprecated(this, 'Color', 'MochiKit.Color.Color', '1.1');
-    m._deprecated(this, 'getElementsComputedStyle', 'MochiKit.Style.getStyle', '1.1');
-
-    m.nameFunctions(this);
-};
-
-MochiKit.Visual.__new__();
-
+MochiKit.Base.nameFunctions(MochiKit.Visual);
 MochiKit.Base._exportSymbols(this, MochiKit.Visual);
diff --git a/frontend/gamma/js/MochiKit/__package__.js b/frontend/gamma/js/MochiKit/__package__.js
deleted file mode 100644
index 8d644b1..0000000
--- a/frontend/gamma/js/MochiKit/__package__.js
+++ b/dev/null
@@ -1,18 +0,0 @@
-dojo.kwCompoundRequire({
-    "common": [
-        "MochiKit.Base",
-        "MochiKit.Iter",
-        "MochiKit.Logging",
-        "MochiKit.DateTime",
-        "MochiKit.Format",
-        "MochiKit.Async",
-        "MochiKit.DOM",
-        "MochiKit.Style",
-        "MochiKit.LoggingPane",
-        "MochiKit.Color",
-        "MochiKit.Signal",
-        "MochiKit.Position",
-        "MochiKit.Visual"
-    ]
-});
-dojo.provide("MochiKit.*");
diff --git a/frontend/gamma/js/main.js b/frontend/gamma/js/main.js
index a9fd65e..934b325 100644
--- a/frontend/gamma/js/main.js
+++ b/frontend/gamma/js/main.js
@@ -20,74 +20,74 @@ refer to http://www.clipperz.com.
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 */
 
 function _pm_logEvent(anEvent) {
 //	console.log("####", anEvent);
 	
 	anEvent.preventDefault();
 }
 
 function handleGenericDeferredError(anError) {
 	var result;
 	
 	if (anError instanceof MochiKit.Async.CancelledError) {
 		result = anError;
 	} else {
 MochiKit.Logging.logError("## MainController - GENERIC ERROR" + "\n" + "==>> " + anError + " <<==\n" + anError.stack);
 //console.log(anError);
 		result = new MochiKit.Async.CancelledError(anError);
 	}
 
 	return result;
 }
 
 
 Clipperz.PM.RunTime = {};
 
 
 function run() {
 	var shouldShowRegistrationForm;
 	var useCompactDesign;
 	var controllerParameters;
 
 	controllerParameters = {};
 
 //	MochiKit.DOM.removeElement('javaScriptAlert');
 	Clipperz.PM.Strings.Languages.initSetup();
 
 	if (window.location.search.indexOf('registration') != -1) {
 		shouldShowRegistrationForm = true;
 	} else {
 		shouldShowRegistrationForm = false;
 	}
 
 	if (window.location.search.indexOf('autocomplete') != -1) {
 		controllerParameters['autocomplete'] = 'on'
 	}
 
 	if (window.location.search.indexOf('compact') != -1) {
 		useCompactDesign = true;
 	} else {
 		useCompactDesign = false;
 	}
 	
 	if (useCompactDesign == true) {
 		Clipperz.PM.RunTime.mainController = new Clipperz.PM.UI.Compact.Controllers.MainController(controllerParameters);
 	} else {
 		Clipperz.PM.RunTime.mainController = new Clipperz.PM.UI.Web.Controllers.MainController(controllerParameters);
 	}
 
 	Clipperz.PM.RunTime.mainController.run(shouldShowRegistrationForm);
 
-//Clipperz.log("HASH: " + window.location.hash);
-if (window.location.hash != "") {
-	window.location.hash = ""
-}
-//Clipperz.log("HASH cleaned");
+	//Clipperz.log("HASH: " + window.location.hash);
+//	if (window.location.hash != "") {
+//		window.location.hash = ""
+//	}
+//	Clipperz.log("HASH cleaned");
 //	#credentials=base64encoded({username:'joe', passphrase:'clipperz'})
 //	MochiKit.Signal.signal(Clipperz.Signal.NotificationCenter, 'doLogin', {username:'joe', passphrase:'clipperz'});
 }
 
 MochiKit.DOM.addLoadEvent(run);