Subversion Repositories Applications.papyrus

/*
        Copyright (c) 2004-2006, The Dojo Foundation
        All Rights Reserved.

        Licensed under the Academic Free License version 2.1 or above OR the
        modified BSD license. For more information on Dojo licensing, see:

                http://dojotoolkit.org/community/licensing.shtml
*/



dojo.provide("dojo.event.common");
dojo.require("dojo.lang.array");
dojo.require("dojo.lang.extras");
dojo.require("dojo.lang.func");
dojo.event = new function () {
        this._canTimeout = dojo.lang.isFunction(dj_global["setTimeout"]) || dojo.lang.isAlien(dj_global["setTimeout"]);
        function interpolateArgs(args, searchForNames) {
                var dl = dojo.lang;
                var ao = {srcObj:dj_global, srcFunc:null, adviceObj:dj_global, adviceFunc:null, aroundObj:null, aroundFunc:null, adviceType:(args.length > 2) ? args[0] : "after", precedence:"last", once:false, delay:null, rate:0, adviceMsg:false, maxCalls:-1};
                switch (args.length) {
                  case 0:
                        return;
                  case 1:
                        return;
                  case 2:
                        ao.srcFunc = args[0];
                        ao.adviceFunc = args[1];
                        break;
                  case 3:
                        if ((dl.isObject(args[0])) && (dl.isString(args[1])) && (dl.isString(args[2]))) {
                                ao.adviceType = "after";
                                ao.srcObj = args[0];
                                ao.srcFunc = args[1];
                                ao.adviceFunc = args[2];
                        } else {
                                if ((dl.isString(args[1])) && (dl.isString(args[2]))) {
                                        ao.srcFunc = args[1];
                                        ao.adviceFunc = args[2];
                                } else {
                                        if ((dl.isObject(args[0])) && (dl.isString(args[1])) && (dl.isFunction(args[2]))) {
                                                ao.adviceType = "after";
                                                ao.srcObj = args[0];
                                                ao.srcFunc = args[1];
                                                var tmpName = dl.nameAnonFunc(args[2], ao.adviceObj, searchForNames);
                                                ao.adviceFunc = tmpName;
                                        } else {
                                                if ((dl.isFunction(args[0])) && (dl.isObject(args[1])) && (dl.isString(args[2]))) {
                                                        ao.adviceType = "after";
                                                        ao.srcObj = dj_global;
                                                        var tmpName = dl.nameAnonFunc(args[0], ao.srcObj, searchForNames);
                                                        ao.srcFunc = tmpName;
                                                        ao.adviceObj = args[1];
                                                        ao.adviceFunc = args[2];
                                                }
                                        }
                                }
                        }
                        break;
                  case 4:
                        if ((dl.isObject(args[0])) && (dl.isObject(args[2]))) {
                                ao.adviceType = "after";
                                ao.srcObj = args[0];
                                ao.srcFunc = args[1];
                                ao.adviceObj = args[2];
                                ao.adviceFunc = args[3];
                        } else {
                                if ((dl.isString(args[0])) && (dl.isString(args[1])) && (dl.isObject(args[2]))) {
                                        ao.adviceType = args[0];
                                        ao.srcObj = dj_global;
                                        ao.srcFunc = args[1];
                                        ao.adviceObj = args[2];
                                        ao.adviceFunc = args[3];
                                } else {
                                        if ((dl.isString(args[0])) && (dl.isFunction(args[1])) && (dl.isObject(args[2]))) {
                                                ao.adviceType = args[0];
                                                ao.srcObj = dj_global;
                                                var tmpName = dl.nameAnonFunc(args[1], dj_global, searchForNames);
                                                ao.srcFunc = tmpName;
                                                ao.adviceObj = args[2];
                                                ao.adviceFunc = args[3];
                                        } else {
                                                if ((dl.isString(args[0])) && (dl.isObject(args[1])) && (dl.isString(args[2])) && (dl.isFunction(args[3]))) {
                                                        ao.srcObj = args[1];
                                                        ao.srcFunc = args[2];
                                                        var tmpName = dl.nameAnonFunc(args[3], dj_global, searchForNames);
                                                        ao.adviceObj = dj_global;
                                                        ao.adviceFunc = tmpName;
                                                } else {
                                                        if (dl.isObject(args[1])) {
                                                                ao.srcObj = args[1];
                                                                ao.srcFunc = args[2];
                                                                ao.adviceObj = dj_global;
                                                                ao.adviceFunc = args[3];
                                                        } else {
                                                                if (dl.isObject(args[2])) {
                                                                        ao.srcObj = dj_global;
                                                                        ao.srcFunc = args[1];
                                                                        ao.adviceObj = args[2];
                                                                        ao.adviceFunc = args[3];
                                                                } else {
                                                                        ao.srcObj = ao.adviceObj = ao.aroundObj = dj_global;
                                                                        ao.srcFunc = args[1];
                                                                        ao.adviceFunc = args[2];
                                                                        ao.aroundFunc = args[3];
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                        break;
                  case 6:
                        ao.srcObj = args[1];
                        ao.srcFunc = args[2];
                        ao.adviceObj = args[3];
                        ao.adviceFunc = args[4];
                        ao.aroundFunc = args[5];
                        ao.aroundObj = dj_global;
                        break;
                  default:
                        ao.srcObj = args[1];
                        ao.srcFunc = args[2];
                        ao.adviceObj = args[3];
                        ao.adviceFunc = args[4];
                        ao.aroundObj = args[5];
                        ao.aroundFunc = args[6];
                        ao.once = args[7];
                        ao.delay = args[8];
                        ao.rate = args[9];
                        ao.adviceMsg = args[10];
                        ao.maxCalls = (!isNaN(parseInt(args[11]))) ? args[11] : -1;
                        break;
                }
                if (dl.isFunction(ao.aroundFunc)) {
                        var tmpName = dl.nameAnonFunc(ao.aroundFunc, ao.aroundObj, searchForNames);
                        ao.aroundFunc = tmpName;
                }
                if (dl.isFunction(ao.srcFunc)) {
                        ao.srcFunc = dl.getNameInObj(ao.srcObj, ao.srcFunc);
                }
                if (dl.isFunction(ao.adviceFunc)) {
                        ao.adviceFunc = dl.getNameInObj(ao.adviceObj, ao.adviceFunc);
                }
                if ((ao.aroundObj) && (dl.isFunction(ao.aroundFunc))) {
                        ao.aroundFunc = dl.getNameInObj(ao.aroundObj, ao.aroundFunc);
                }
                if (!ao.srcObj) {
                        dojo.raise("bad srcObj for srcFunc: " + ao.srcFunc);
                }
                if (!ao.adviceObj) {
                        dojo.raise("bad adviceObj for adviceFunc: " + ao.adviceFunc);
                }
                if (!ao.adviceFunc) {
                        dojo.debug("bad adviceFunc for srcFunc: " + ao.srcFunc);
                        dojo.debugShallow(ao);
                }
                return ao;
        }
        this.connect = function () {
                if (arguments.length == 1) {
                        var ao = arguments[0];
                } else {
                        var ao = interpolateArgs(arguments, true);
                }
                if (dojo.lang.isString(ao.srcFunc) && (ao.srcFunc.toLowerCase() == "onkey")) {
                        if (dojo.render.html.ie) {
                                ao.srcFunc = "onkeydown";
                                this.connect(ao);
                        }
                        ao.srcFunc = "onkeypress";
                }
                if (dojo.lang.isArray(ao.srcObj) && ao.srcObj != "") {
                        var tmpAO = {};
                        for (var x in ao) {
                                tmpAO[x] = ao[x];
                        }
                        var mjps = [];
                        dojo.lang.forEach(ao.srcObj, function (src) {
                                if ((dojo.render.html.capable) && (dojo.lang.isString(src))) {
                                        src = dojo.byId(src);
                                }
                                tmpAO.srcObj = src;
                                mjps.push(dojo.event.connect.call(dojo.event, tmpAO));
                        });
                        return mjps;
                }
                var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc);
                if (ao.adviceFunc) {
                        var mjp2 = dojo.event.MethodJoinPoint.getForMethod(ao.adviceObj, ao.adviceFunc);
                }
                mjp.kwAddAdvice(ao);
                return mjp;
        };
        this.log = function (a1, a2) {
                var kwArgs;
                if ((arguments.length == 1) && (typeof a1 == "object")) {
                        kwArgs = a1;
                } else {
                        kwArgs = {srcObj:a1, srcFunc:a2};
                }
                kwArgs.adviceFunc = function () {
                        var argsStr = [];
                        for (var x = 0; x < arguments.length; x++) {
                                argsStr.push(arguments[x]);
                        }
                        dojo.debug("(" + kwArgs.srcObj + ")." + kwArgs.srcFunc, ":", argsStr.join(", "));
                };
                this.kwConnect(kwArgs);
        };
        this.connectBefore = function () {
                var args = ["before"];
                for (var i = 0; i < arguments.length; i++) {
                        args.push(arguments[i]);
                }
                return this.connect.apply(this, args);
        };
        this.connectAround = function () {
                var args = ["around"];
                for (var i = 0; i < arguments.length; i++) {
                        args.push(arguments[i]);
                }
                return this.connect.apply(this, args);
        };
        this.connectOnce = function () {
                var ao = interpolateArgs(arguments, true);
                ao.once = true;
                return this.connect(ao);
        };
        this.connectRunOnce = function () {
                var ao = interpolateArgs(arguments, true);
                ao.maxCalls = 1;
                return this.connect(ao);
        };
        this._kwConnectImpl = function (kwArgs, disconnect) {
                var fn = (disconnect) ? "disconnect" : "connect";
                if (typeof kwArgs["srcFunc"] == "function") {
                        kwArgs.srcObj = kwArgs["srcObj"] || dj_global;
                        var tmpName = dojo.lang.nameAnonFunc(kwArgs.srcFunc, kwArgs.srcObj, true);
                        kwArgs.srcFunc = tmpName;
                }
                if (typeof kwArgs["adviceFunc"] == "function") {
                        kwArgs.adviceObj = kwArgs["adviceObj"] || dj_global;
                        var tmpName = dojo.lang.nameAnonFunc(kwArgs.adviceFunc, kwArgs.adviceObj, true);
                        kwArgs.adviceFunc = tmpName;
                }
                kwArgs.srcObj = kwArgs["srcObj"] || dj_global;
                kwArgs.adviceObj = kwArgs["adviceObj"] || kwArgs["targetObj"] || dj_global;
                kwArgs.adviceFunc = kwArgs["adviceFunc"] || kwArgs["targetFunc"];
                return dojo.event[fn](kwArgs);
        };
        this.kwConnect = function (kwArgs) {
                return this._kwConnectImpl(kwArgs, false);
        };
        this.disconnect = function () {
                if (arguments.length == 1) {
                        var ao = arguments[0];
                } else {
                        var ao = interpolateArgs(arguments, true);
                }
                if (!ao.adviceFunc) {
                        return;
                }
                if (dojo.lang.isString(ao.srcFunc) && (ao.srcFunc.toLowerCase() == "onkey")) {
                        if (dojo.render.html.ie) {
                                ao.srcFunc = "onkeydown";
                                this.disconnect(ao);
                        }
                        ao.srcFunc = "onkeypress";
                }
                if (!ao.srcObj[ao.srcFunc]) {
                        return null;
                }
                var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc, true);
                mjp.removeAdvice(ao.adviceObj, ao.adviceFunc, ao.adviceType, ao.once);
                return mjp;
        };
        this.kwDisconnect = function (kwArgs) {
                return this._kwConnectImpl(kwArgs, true);
        };
};
dojo.event.MethodInvocation = function (join_point, obj, args) {
        this.jp_ = join_point;
        this.object = obj;
        this.args = [];
        for (var x = 0; x < args.length; x++) {
                this.args[x] = args[x];
        }
        this.around_index = -1;
};
dojo.event.MethodInvocation.prototype.proceed = function () {
        this.around_index++;
        if (this.around_index >= this.jp_.around.length) {
                return this.jp_.object[this.jp_.methodname].apply(this.jp_.object, this.args);
        } else {
                var ti = this.jp_.around[this.around_index];
                var mobj = ti[0] || dj_global;
                var meth = ti[1];
                return mobj[meth].call(mobj, this);
        }
};
dojo.event.MethodJoinPoint = function (obj, funcName) {
        this.object = obj || dj_global;
        this.methodname = funcName;
        this.methodfunc = this.object[funcName];
        this.squelch = false;
};
dojo.event.MethodJoinPoint.getForMethod = function (obj, funcName) {
        if (!obj) {
                obj = dj_global;
        }
        var ofn = obj[funcName];
        if (!ofn) {
                ofn = obj[funcName] = function () {
                };
                if (!obj[funcName]) {
                        dojo.raise("Cannot set do-nothing method on that object " + funcName);
                }
        } else {
                if ((typeof ofn != "function") && (!dojo.lang.isFunction(ofn)) && (!dojo.lang.isAlien(ofn))) {
                        return null;
                }
        }
        var jpname = funcName + "$joinpoint";
        var jpfuncname = funcName + "$joinpoint$method";
        var joinpoint = obj[jpname];
        if (!joinpoint) {
                var isNode = false;
                if (dojo.event["browser"]) {
                        if ((obj["attachEvent"]) || (obj["nodeType"]) || (obj["addEventListener"])) {
                                isNode = true;
                                dojo.event.browser.addClobberNodeAttrs(obj, [jpname, jpfuncname, funcName]);
                        }
                }
                var origArity = ofn.length;
                obj[jpfuncname] = ofn;
                joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, jpfuncname);
                if (!isNode) {
                        obj[funcName] = function () {
                                return joinpoint.run.apply(joinpoint, arguments);
                        };
                } else {
                        obj[funcName] = function () {
                                var args = [];
                                if (!arguments.length) {
                                        var evt = null;
                                        try {
                                                if (obj.ownerDocument) {
                                                        evt = obj.ownerDocument.parentWindow.event;
                                                } else {
                                                        if (obj.documentElement) {
                                                                evt = obj.documentElement.ownerDocument.parentWindow.event;
                                                        } else {
                                                                if (obj.event) {
                                                                        evt = obj.event;
                                                                } else {
                                                                        evt = window.event;
                                                                }
                                                        }
                                                }
                                        }
                                        catch (e) {
                                                evt = window.event;
                                        }
                                        if (evt) {
                                                args.push(dojo.event.browser.fixEvent(evt, this));
                                        }
                                } else {
                                        for (var x = 0; x < arguments.length; x++) {
                                                if ((x == 0) && (dojo.event.browser.isEvent(arguments[x]))) {
                                                        args.push(dojo.event.browser.fixEvent(arguments[x], this));
                                                } else {
                                                        args.push(arguments[x]);
                                                }
                                        }
                                }
                                return joinpoint.run.apply(joinpoint, args);
                        };
                }
                obj[funcName].__preJoinArity = origArity;
        }
        return joinpoint;
};
dojo.lang.extend(dojo.event.MethodJoinPoint, {squelch:false, unintercept:function () {
        this.object[this.methodname] = this.methodfunc;
        this.before = [];
        this.after = [];
        this.around = [];
}, disconnect:dojo.lang.forward("unintercept"), run:function () {
        var obj = this.object || dj_global;
        var args = arguments;
        var aargs = [];
        for (var x = 0; x < args.length; x++) {
                aargs[x] = args[x];
        }
        var unrollAdvice = function (marr) {
                if (!marr) {
                        dojo.debug("Null argument to unrollAdvice()");
                        return;
                }
                var callObj = marr[0] || dj_global;
                var callFunc = marr[1];
                if (!callObj[callFunc]) {
                        dojo.raise("function \"" + callFunc + "\" does not exist on \"" + callObj + "\"");
                }
                var aroundObj = marr[2] || dj_global;
                var aroundFunc = marr[3];
                var msg = marr[6];
                var maxCount = marr[7];
                if (maxCount > -1) {
                        if (maxCount == 0) {
                                return;
                        }
                        marr[7]--;
                }
                var undef;
                var to = {args:[], jp_:this, object:obj, proceed:function () {
                        return callObj[callFunc].apply(callObj, to.args);
                }};
                to.args = aargs;
                var delay = parseInt(marr[4]);
                var hasDelay = ((!isNaN(delay)) && (marr[4] !== null) && (typeof marr[4] != "undefined"));
                if (marr[5]) {
                        var rate = parseInt(marr[5]);
                        var cur = new Date();
                        var timerSet = false;
                        if ((marr["last"]) && ((cur - marr.last) <= rate)) {
                                if (dojo.event._canTimeout) {
                                        if (marr["delayTimer"]) {
                                                clearTimeout(marr.delayTimer);
                                        }
                                        var tod = parseInt(rate * 2);
                                        var mcpy = dojo.lang.shallowCopy(marr);
                                        marr.delayTimer = setTimeout(function () {
                                                mcpy[5] = 0;
                                                unrollAdvice(mcpy);
                                        }, tod);
                                }
                                return;
                        } else {
                                marr.last = cur;
                        }
                }
                if (aroundFunc) {
                        aroundObj[aroundFunc].call(aroundObj, to);
                } else {
                        if ((hasDelay) && ((dojo.render.html) || (dojo.render.svg))) {
                                dj_global["setTimeout"](function () {
                                        if (msg) {
                                                callObj[callFunc].call(callObj, to);
                                        } else {
                                                callObj[callFunc].apply(callObj, args);
                                        }
                                }, delay);
                        } else {
                                if (msg) {
                                        callObj[callFunc].call(callObj, to);
                                } else {
                                        callObj[callFunc].apply(callObj, args);
                                }
                        }
                }
        };
        var unRollSquelch = function () {
                if (this.squelch) {
                        try {
                                return unrollAdvice.apply(this, arguments);
                        }
                        catch (e) {
                                dojo.debug(e);
                        }
                } else {
                        return unrollAdvice.apply(this, arguments);
                }
        };
        if ((this["before"]) && (this.before.length > 0)) {
                dojo.lang.forEach(this.before.concat(new Array()), unRollSquelch);
        }
        var result;
        try {
                if ((this["around"]) && (this.around.length > 0)) {
                        var mi = new dojo.event.MethodInvocation(this, obj, args);
                        result = mi.proceed();
                } else {
                        if (this.methodfunc) {
                                result = this.object[this.methodname].apply(this.object, args);
                        }
                }
        }
        catch (e) {
                if (!this.squelch) {
                        dojo.debug(e, "when calling", this.methodname, "on", this.object, "with arguments", args);
                        dojo.raise(e);
                }
        }
        if ((this["after"]) && (this.after.length > 0)) {
                dojo.lang.forEach(this.after.concat(new Array()), unRollSquelch);
        }
        return (this.methodfunc) ? result : null;
}, getArr:function (kind) {
        var type = "after";
        if ((typeof kind == "string") && (kind.indexOf("before") != -1)) {
                type = "before";
        } else {
                if (kind == "around") {
                        type = "around";
                }
        }
        if (!this[type]) {
                this[type] = [];
        }
        return this[type];
}, kwAddAdvice:function (args) {
        this.addAdvice(args["adviceObj"], args["adviceFunc"], args["aroundObj"], args["aroundFunc"], args["adviceType"], args["precedence"], args["once"], args["delay"], args["rate"], args["adviceMsg"], args["maxCalls"]);
}, addAdvice:function (thisAdviceObj, thisAdvice, thisAroundObj, thisAround, adviceType, precedence, once, delay, rate, asMessage, maxCalls) {
        var arr = this.getArr(adviceType);
        if (!arr) {
                dojo.raise("bad this: " + this);
        }
        var ao = [thisAdviceObj, thisAdvice, thisAroundObj, thisAround, delay, rate, asMessage, maxCalls];
        if (once) {
                if (this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr) >= 0) {
                        return;
                }
        }
        if (precedence == "first") {
                arr.unshift(ao);
        } else {
                arr.push(ao);
        }
}, hasAdvice:function (thisAdviceObj, thisAdvice, adviceType, arr) {
        if (!arr) {
                arr = this.getArr(adviceType);
        }
        var ind = -1;
        for (var x = 0; x < arr.length; x++) {
                var aao = (typeof thisAdvice == "object") ? (new String(thisAdvice)).toString() : thisAdvice;
                var a1o = (typeof arr[x][1] == "object") ? (new String(arr[x][1])).toString() : arr[x][1];
                if ((arr[x][0] == thisAdviceObj) && (a1o == aao)) {
                        ind = x;
                }
        }
        return ind;
}, removeAdvice:function (thisAdviceObj, thisAdvice, adviceType, once) {
        var arr = this.getArr(adviceType);
        var ind = this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr);
        if (ind == -1) {
                return false;
        }
        while (ind != -1) {
                arr.splice(ind, 1);
                if (once) {
                        break;
                }
                ind = this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr);
        }
        return true;
}});