Added: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/common.js URL: http://svn.apache.org/viewvc/geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/common.js?rev=794787&view=auto ============================================================================== --- geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/common.js (added) +++ geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/common.js Thu Jul 16 19:14:41 2009 @@ -0,0 +1,560 @@ +/* + 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; +}}); + Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/common.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/common.js ------------------------------------------------------------------------------ svn:keywords = Date Revision Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/common.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/topic.js URL: http://svn.apache.org/viewvc/geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/topic.js?rev=794787&view=auto ============================================================================== --- geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/topic.js (added) +++ geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/topic.js Thu Jul 16 19:14:41 2009 @@ -0,0 +1,79 @@ +/* + 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.require("dojo.event.common"); +dojo.provide("dojo.event.topic"); +dojo.event.topic = new function () { + this.topics = {}; + this.getTopic = function (topic) { + if (!this.topics[topic]) { + this.topics[topic] = new this.TopicImpl(topic); + } + return this.topics[topic]; + }; + this.registerPublisher = function (topic, obj, funcName) { + var topic = this.getTopic(topic); + topic.registerPublisher(obj, funcName); + }; + this.subscribe = function (topic, obj, funcName) { + var topic = this.getTopic(topic); + topic.subscribe(obj, funcName); + }; + this.unsubscribe = function (topic, obj, funcName) { + var topic = this.getTopic(topic); + topic.unsubscribe(obj, funcName); + }; + this.destroy = function (topic) { + this.getTopic(topic).destroy(); + delete this.topics[topic]; + }; + this.publishApply = function (topic, args) { + var topic = this.getTopic(topic); + topic.sendMessage.apply(topic, args); + }; + this.publish = function (topic, message) { + var topic = this.getTopic(topic); + var args = []; + for (var x = 1; x < arguments.length; x++) { + args.push(arguments[x]); + } + topic.sendMessage.apply(topic, args); + }; +}; +dojo.event.topic.TopicImpl = function (topicName) { + this.topicName = topicName; + this.subscribe = function (listenerObject, listenerMethod) { + var tf = listenerMethod || listenerObject; + var to = (!listenerMethod) ? dj_global : listenerObject; + return dojo.event.kwConnect({srcObj:this, srcFunc:"sendMessage", adviceObj:to, adviceFunc:tf}); + }; + this.unsubscribe = function (listenerObject, listenerMethod) { + var tf = (!listenerMethod) ? listenerObject : listenerMethod; + var to = (!listenerMethod) ? null : listenerObject; + return dojo.event.kwDisconnect({srcObj:this, srcFunc:"sendMessage", adviceObj:to, adviceFunc:tf}); + }; + this._getJoinPoint = function () { + return dojo.event.MethodJoinPoint.getForMethod(this, "sendMessage"); + }; + this.setSquelch = function (shouldSquelch) { + this._getJoinPoint().squelch = shouldSquelch; + }; + this.destroy = function () { + this._getJoinPoint().disconnect(); + }; + this.registerPublisher = function (publisherObject, publisherMethod) { + dojo.event.connect(publisherObject, publisherMethod, this, "sendMessage"); + }; + this.sendMessage = function (message) { + }; +}; + Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/topic.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/topic.js ------------------------------------------------------------------------------ svn:keywords = Date Revision Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/event/topic.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/experimental.js URL: http://svn.apache.org/viewvc/geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/experimental.js?rev=794787&view=auto ============================================================================== --- geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/experimental.js (added) +++ geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/experimental.js Thu Jul 16 19:14:41 2009 @@ -0,0 +1,22 @@ +/* + 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.experimental"); +dojo.experimental = function (moduleName, extra) { + var message = "EXPERIMENTAL: " + moduleName; + message += " -- Not yet ready for use. APIs subject to change without notice."; + if (extra) { + message += " " + extra; + } + dojo.debug(message); +}; + Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/experimental.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/experimental.js ------------------------------------------------------------------------------ svn:keywords = Date Revision Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/experimental.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash.js URL: http://svn.apache.org/viewvc/geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash.js?rev=794787&view=auto ============================================================================== --- geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash.js (added) +++ geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash.js Thu Jul 16 19:14:41 2009 @@ -0,0 +1,446 @@ +/* + 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.flash"); +dojo.require("dojo.string.*"); +dojo.require("dojo.uri.*"); +dojo.require("dojo.html.common"); +dojo.flash = function () { +}; +dojo.flash = {flash6_version:null, flash8_version:null, ready:false, _visible:true, _loadedListeners:new Array(), _installingListeners:new Array(), setSwf:function (fileInfo) { + if (fileInfo == null || dojo.lang.isUndefined(fileInfo)) { + return; + } + if (fileInfo.flash6 != null && !dojo.lang.isUndefined(fileInfo.flash6)) { + this.flash6_version = fileInfo.flash6; + } + if (fileInfo.flash8 != null && !dojo.lang.isUndefined(fileInfo.flash8)) { + this.flash8_version = fileInfo.flash8; + } + if (!dojo.lang.isUndefined(fileInfo.visible)) { + this._visible = fileInfo.visible; + } + this._initialize(); +}, useFlash6:function () { + if (this.flash6_version == null) { + return false; + } else { + if (this.flash6_version != null && dojo.flash.info.commVersion == 6) { + return true; + } else { + return false; + } + } +}, useFlash8:function () { + if (this.flash8_version == null) { + return false; + } else { + if (this.flash8_version != null && dojo.flash.info.commVersion == 8) { + return true; + } else { + return false; + } + } +}, addLoadedListener:function (listener) { + this._loadedListeners.push(listener); +}, addInstallingListener:function (listener) { + this._installingListeners.push(listener); +}, loaded:function () { + dojo.flash.ready = true; + if (dojo.flash._loadedListeners.length > 0) { + for (var i = 0; i < dojo.flash._loadedListeners.length; i++) { + dojo.flash._loadedListeners[i].call(null); + } + } +}, installing:function () { + if (dojo.flash._installingListeners.length > 0) { + for (var i = 0; i < dojo.flash._installingListeners.length; i++) { + dojo.flash._installingListeners[i].call(null); + } + } +}, _initialize:function () { + var installer = new dojo.flash.Install(); + dojo.flash.installer = installer; + if (installer.needed() == true) { + installer.install(); + } else { + dojo.flash.obj = new dojo.flash.Embed(this._visible); + dojo.flash.obj.write(dojo.flash.info.commVersion); + dojo.flash.comm = new dojo.flash.Communicator(); + } +}}; +dojo.flash.Info = function () { + if (dojo.render.html.ie) { + document.writeln(""); + } + this._detectVersion(); + this._detectCommunicationVersion(); +}; +dojo.flash.Info.prototype = {version:-1, versionMajor:-1, versionMinor:-1, versionRevision:-1, capable:false, commVersion:6, installing:false, isVersionOrAbove:function (reqMajorVer, reqMinorVer, reqVer) { + reqVer = parseFloat("." + reqVer); + if (this.versionMajor >= reqMajorVer && this.versionMinor >= reqMinorVer && this.versionRevision >= reqVer) { + return true; + } else { + return false; + } +}, _detectVersion:function () { + var versionStr; + for (var testVersion = 25; testVersion > 0; testVersion--) { + if (dojo.render.html.ie) { + versionStr = VBGetSwfVer(testVersion); + } else { + versionStr = this._JSFlashInfo(testVersion); + } + if (versionStr == -1) { + this.capable = false; + return; + } else { + if (versionStr != 0) { + var versionArray; + if (dojo.render.html.ie) { + var tempArray = versionStr.split(" "); + var tempString = tempArray[1]; + versionArray = tempString.split(","); + } else { + versionArray = versionStr.split("."); + } + this.versionMajor = versionArray[0]; + this.versionMinor = versionArray[1]; + this.versionRevision = versionArray[2]; + var versionString = this.versionMajor + "." + this.versionRevision; + this.version = parseFloat(versionString); + this.capable = true; + break; + } + } + } +}, _JSFlashInfo:function (testVersion) { + if (navigator.plugins != null && navigator.plugins.length > 0) { + if (navigator.plugins["Shockwave Flash 2.0"] || navigator.plugins["Shockwave Flash"]) { + var swVer2 = navigator.plugins["Shockwave Flash 2.0"] ? " 2.0" : ""; + var flashDescription = navigator.plugins["Shockwave Flash" + swVer2].description; + var descArray = flashDescription.split(" "); + var tempArrayMajor = descArray[2].split("."); + var versionMajor = tempArrayMajor[0]; + var versionMinor = tempArrayMajor[1]; + if (descArray[3] != "") { + var tempArrayMinor = descArray[3].split("r"); + } else { + var tempArrayMinor = descArray[4].split("r"); + } + var versionRevision = tempArrayMinor[1] > 0 ? tempArrayMinor[1] : 0; + var version = versionMajor + "." + versionMinor + "." + versionRevision; + return version; + } + } + return -1; +}, _detectCommunicationVersion:function () { + if (this.capable == false) { + this.commVersion = null; + return; + } + if (typeof djConfig["forceFlashComm"] != "undefined" && typeof djConfig["forceFlashComm"] != null) { + this.commVersion = djConfig["forceFlashComm"]; + return; + } + if (dojo.render.html.safari == true || dojo.render.html.opera == true) { + this.commVersion = 8; + } else { + this.commVersion = 6; + } +}}; +dojo.flash.Embed = function (visible) { + this._visible = visible; +}; +dojo.flash.Embed.prototype = {width:215, height:138, id:"flashObject", _visible:true, protocol:function () { + switch (window.location.protocol) { + case "https:": + return "https"; + break; + default: + return "http"; + break; + } +}, write:function (flashVer, doExpressInstall) { + if (dojo.lang.isUndefined(doExpressInstall)) { + doExpressInstall = false; + } + var containerStyle = new dojo.string.Builder(); + containerStyle.append("width: " + this.width + "px; "); + containerStyle.append("height: " + this.height + "px; "); + if (this._visible == false) { + containerStyle.append("position: absolute; "); + containerStyle.append("z-index: 10000; "); + containerStyle.append("top: -1000px; "); + containerStyle.append("left: -1000px; "); + } + containerStyle = containerStyle.toString(); + var objectHTML; + var swfloc; + if (flashVer == 6) { + swfloc = dojo.flash.flash6_version; + var dojoPath = djConfig.baseRelativePath; + swfloc = swfloc + "?baseRelativePath=" + escape(dojoPath); + objectHTML = ""; + } else { + swfloc = dojo.flash.flash8_version; + var swflocObject = swfloc; + var swflocEmbed = swfloc; + var dojoPath = djConfig.baseRelativePath; + if (doExpressInstall) { + var redirectURL = escape(window.location); + document.title = document.title.slice(0, 47) + " - Flash Player Installation"; + var docTitle = escape(document.title); + swflocObject += "?MMredirectURL=" + redirectURL + "&MMplayerType=ActiveX" + "&MMdoctitle=" + docTitle + "&baseRelativePath=" + escape(dojoPath); + swflocEmbed += "?MMredirectURL=" + redirectURL + "&MMplayerType=PlugIn" + "&baseRelativePath=" + escape(dojoPath); + } + if (swflocEmbed.indexOf("?") == -1) { + swflocEmbed += "?baseRelativePath=" + escape(dojoPath) + "' "; + } + objectHTML = " " + " " + " " + " " + " " + "" + ""; + } + objectHTML = "
" + objectHTML + "
"; + document.writeln(objectHTML); +}, get:function () { + return document.getElementById(this.id); +}, setVisible:function (visible) { + var container = dojo.byId(this.id + "Container"); + if (visible == true) { + container.style.visibility = "visible"; + } else { + container.style.position = "absolute"; + container.style.x = "-1000px"; + container.style.y = "-1000px"; + container.style.visibility = "hidden"; + } +}, center:function () { + var elementWidth = this.width; + var elementHeight = this.height; + var scroll_offset = dojo.html.getScroll().offset; + var viewport_size = dojo.html.getViewport(); + var x = scroll_offset.x + (viewport_size.width - elementWidth) / 2; + var y = scroll_offset.y + (viewport_size.height - elementHeight) / 2; + var container = dojo.byId(this.id + "Container"); + container.style.top = y + "px"; + container.style.left = x + "px"; +}}; +dojo.flash.Communicator = function () { + if (dojo.flash.useFlash6()) { + this._writeFlash6(); + } else { + if (dojo.flash.useFlash8()) { + this._writeFlash8(); + } + } +}; +dojo.flash.Communicator.prototype = {_writeFlash6:function () { + var id = dojo.flash.obj.id; + document.writeln(""); + if (dojo.render.html.ie) { + document.writeln(" "); + } +}, _writeFlash8:function () { +}, _handleFSCommand:function (command, args) { + if (command != null && !dojo.lang.isUndefined(command) && /^FSCommand:(.*)/.test(command) == true) { + command = command.match(/^FSCommand:(.*)/)[1]; + } + if (command == "addCallback") { + this._fscommandAddCallback(command, args); + } else { + if (command == "call") { + this._fscommandCall(command, args); + } else { + if (command == "fscommandReady") { + this._fscommandReady(); + } + } + } +}, _fscommandAddCallback:function (command, args) { + var functionName = args; + var callFunc = function () { + return dojo.flash.comm._call(functionName, arguments); + }; + dojo.flash.comm[functionName] = callFunc; + dojo.flash.obj.get().SetVariable("_succeeded", true); +}, _fscommandCall:function (command, args) { + var plugin = dojo.flash.obj.get(); + var functionName = args; + var numArgs = parseInt(plugin.GetVariable("_numArgs")); + var flashArgs = new Array(); + for (var i = 0; i < numArgs; i++) { + var currentArg = plugin.GetVariable("_" + i); + flashArgs.push(currentArg); + } + var runMe; + if (functionName.indexOf(".") == -1) { + runMe = window[functionName]; + } else { + runMe = eval(functionName); + } + var results = null; + if (!dojo.lang.isUndefined(runMe) && runMe != null) { + results = runMe.apply(null, flashArgs); + } + plugin.SetVariable("_returnResult", results); +}, _fscommandReady:function () { + var plugin = dojo.flash.obj.get(); + plugin.SetVariable("fscommandReady", "true"); +}, _call:function (functionName, args) { + var plugin = dojo.flash.obj.get(); + plugin.SetVariable("_functionName", functionName); + plugin.SetVariable("_numArgs", args.length); + for (var i = 0; i < args.length; i++) { + var value = args[i]; + value = value.replace(/\0/g, "\\0"); + plugin.SetVariable("_" + i, value); + } + plugin.TCallLabel("/_flashRunner", "execute"); + var results = plugin.GetVariable("_returnResult"); + results = results.replace(/\\0/g, "\x00"); + return results; +}, _addExternalInterfaceCallback:function (methodName) { + var wrapperCall = function () { + var methodArgs = new Array(arguments.length); + for (var i = 0; i < arguments.length; i++) { + methodArgs[i] = arguments[i]; + } + return dojo.flash.comm._execFlash(methodName, methodArgs); + }; + dojo.flash.comm[methodName] = wrapperCall; +}, _encodeData:function (data) { + var entityRE = /\&([^;]*)\;/g; + data = data.replace(entityRE, "&$1;"); + data = data.replace(//g, ">"); + data = data.replace("\\", "&custom_backslash;&custom_backslash;"); + data = data.replace(/\n/g, "\\n"); + data = data.replace(/\r/g, "\\r"); + data = data.replace(/\f/g, "\\f"); + data = data.replace(/\0/g, "\\0"); + data = data.replace(/\'/g, "\\'"); + data = data.replace(/\"/g, "\\\""); + return data; +}, _decodeData:function (data) { + if (data == null || typeof data == "undefined") { + return data; + } + data = data.replace(/\&custom_lt\;/g, "<"); + data = data.replace(/\&custom_gt\;/g, ">"); + data = eval("\"" + data + "\""); + return data; +}, _chunkArgumentData:function (value, argIndex) { + var plugin = dojo.flash.obj.get(); + var numSegments = Math.ceil(value.length / 1024); + for (var i = 0; i < numSegments; i++) { + var startCut = i * 1024; + var endCut = i * 1024 + 1024; + if (i == (numSegments - 1)) { + endCut = i * 1024 + value.length; + } + var piece = value.substring(startCut, endCut); + piece = this._encodeData(piece); + plugin.CallFunction("" + "" + "" + piece + "" + "" + argIndex + "" + "" + ""); + } +}, _chunkReturnData:function () { + var plugin = dojo.flash.obj.get(); + var numSegments = plugin.getReturnLength(); + var resultsArray = new Array(); + for (var i = 0; i < numSegments; i++) { + var piece = plugin.CallFunction("" + "" + "" + i + "" + "" + ""); + if (piece == "\"\"" || piece == "''") { + piece = ""; + } else { + piece = piece.substring(1, piece.length - 1); + } + resultsArray.push(piece); + } + var results = resultsArray.join(""); + return results; +}, _execFlash:function (methodName, methodArgs) { + var plugin = dojo.flash.obj.get(); + plugin.startExec(); + plugin.setNumberArguments(methodArgs.length); + for (var i = 0; i < methodArgs.length; i++) { + this._chunkArgumentData(methodArgs[i], i); + } + plugin.exec(methodName); + var results = this._chunkReturnData(); + results = this._decodeData(results); + plugin.endExec(); + return results; +}}; +dojo.flash.Install = function () { +}; +dojo.flash.Install.prototype = {needed:function () { + if (dojo.flash.info.capable == false) { + return true; + } + if (dojo.render.os.mac == true && !dojo.flash.info.isVersionOrAbove(8, 0, 0)) { + return true; + } + if (!dojo.flash.info.isVersionOrAbove(6, 0, 0)) { + return true; + } + return false; +}, install:function () { + dojo.flash.info.installing = true; + dojo.flash.installing(); + if (dojo.flash.info.capable == false) { + var installObj = new dojo.flash.Embed(false); + installObj.write(8); + } else { + if (dojo.flash.info.isVersionOrAbove(6, 0, 65)) { + var installObj = new dojo.flash.Embed(false); + installObj.write(8, true); + installObj.setVisible(true); + installObj.center(); + } else { + alert("This content requires a more recent version of the Macromedia " + " Flash Player."); + window.location.href = +dojo.flash.Embed.protocol() + "://www.macromedia.com/go/getflashplayer"; + } + } +}, _onInstallStatus:function (msg) { + if (msg == "Download.Complete") { + dojo.flash._initialize(); + } else { + if (msg == "Download.Cancelled") { + alert("This content requires a more recent version of the Macromedia " + " Flash Player."); + window.location.href = dojo.flash.Embed.protocol() + "://www.macromedia.com/go/getflashplayer"; + } else { + if (msg == "Download.Failed") { + alert("There was an error downloading the Flash Player update. " + "Please try again later, or visit macromedia.com to download " + "the latest version of the Flash plugin."); + } + } + } +}}; +dojo.flash.info = new dojo.flash.Info(); + Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash.js ------------------------------------------------------------------------------ svn:keywords = Date Revision Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash6/DojoExternalInterface.as URL: http://svn.apache.org/viewvc/geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash6/DojoExternalInterface.as?rev=794787&view=auto ============================================================================== --- geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash6/DojoExternalInterface.as (added) +++ geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash6/DojoExternalInterface.as Thu Jul 16 19:14:41 2009 @@ -0,0 +1,215 @@ +/* + 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 +*/ + +/** + An implementation of Flash 8's ExternalInterface that works with Flash 6 + and which is source-compatible with Flash 8. + + @author Brad Neuberg, bkn3@columbia.edu +*/ + +class DojoExternalInterface{ + public static var available:Boolean; + public static var dojoPath = ""; + + public static var _fscommandReady = false; + public static var _callbacks = new Array(); + + public static function initialize(){ + //getURL("javascript:dojo.debug('FLASH:DojoExternalInterface initialize')"); + // FIXME: Set available variable by testing for capabilities + DojoExternalInterface.available = true; + + // extract the dojo base path + DojoExternalInterface.dojoPath = DojoExternalInterface.getDojoPath(); + //getURL("javascript:dojo.debug('FLASH:dojoPath="+DojoExternalInterface.dojoPath+"')"); + + // Sometimes, on IE, the fscommand infrastructure can take a few hundred + // milliseconds the first time a page loads. Set a timer to keep checking + // to make sure we can issue fscommands; otherwise, our calls to fscommand + // for setCallback() and loaded() will just "disappear" + _root.fscommandReady = false; + var fsChecker = function(){ + // issue a test fscommand + fscommand("fscommandReady"); + + // JavaScript should set _root.fscommandReady if it got the call + if(_root.fscommandReady == "true"){ + DojoExternalInterface._fscommandReady = true; + clearInterval(_root.fsTimer); + } + }; + _root.fsTimer = setInterval(fsChecker, 100); + } + + public static function addCallback(methodName:String, instance:Object, + method:Function) : Boolean{ + // A variable that indicates whether the call below succeeded + _root._succeeded = null; + + // Callbacks are registered with the JavaScript side as follows. + // On the Flash side, we maintain a lookup table that associates + // the methodName with the actual instance and method that are + // associated with this method. + // Using fscommand, we send over the action "addCallback", with the + // argument being the methodName to add, such as "foobar". + // The JavaScript takes these values and registers the existence of + // this callback point. + + // precede the method name with a _ character in case it starts + // with a number + _callbacks["_" + methodName] = {_instance: instance, _method: method}; + _callbacks[_callbacks.length] = methodName; + + // The API for ExternalInterface says we have to make sure the call + // succeeded; check to see if there is a value + // for _succeeded, which is set by the JavaScript side + if(_root._succeeded == null){ + return false; + }else{ + return true; + } + } + + public static function call(methodName:String, + resultsCallback:Function) : Void{ + // FIXME: support full JSON serialization + + // First, we pack up all of the arguments to this call and set them + // as Flash variables, which the JavaScript side will unpack using + // plugin.GetVariable(). We set the number of arguments as "_numArgs", + // and add each argument as a variable, such as "_1", "_2", etc., starting + // from 0. + // We then execute an fscommand with the action "call" and the + // argument being the method name. JavaScript takes the method name, + // retrieves the arguments using GetVariable, executes the method, + // and then places the return result in a Flash variable + // named "_returnResult". + _root._numArgs = arguments.length - 2; + for(var i = 2; i < arguments.length; i++){ + var argIndex = i - 2; + _root["_" + argIndex] = arguments[i]; + } + + _root._returnResult = undefined; + fscommand("call", methodName); + + // immediately return if the caller is not waiting for return results + if(resultsCallback == undefined || resultsCallback == null){ + return; + } + + // check at regular intervals for return results + var resultsChecker = function(){ + if((typeof _root._returnResult != "undefined")&& + (_root._returnResult != "undefined")){ + clearInterval(_root._callbackID); + resultsCallback.call(null, _root._returnResult); + } + }; + _root._callbackID = setInterval(resultsChecker, 100); + } + + /** + Called by Flash to indicate to JavaScript that we are ready to have + our Flash functions called. Calling loaded() + will fire the dojo.flash.loaded() event, so that JavaScript can know that + Flash has finished loading and adding its callbacks, and can begin to + interact with the Flash file. + */ + public static function loaded(){ + //getURL("javascript:dojo.debug('FLASH:loaded')"); + + // one more step: see if fscommands are ready to be executed; if not, + // set an interval that will keep running until fscommands are ready; + // make sure the gateway is loaded as well + var execLoaded = function(){ + if(DojoExternalInterface._fscommandReady == true){ + clearInterval(_root.loadedInterval); + + // initialize the small Flash file that helps gateway JS to Flash + // calls + DojoExternalInterface._initializeFlashRunner(); + } + }; + + if(_fscommandReady == true){ + execLoaded(); + }else{ + _root.loadedInterval = setInterval(execLoaded, 50); + } + } + + /** + Handles and executes a JavaScript to Flash method call. Used by + initializeFlashRunner. + */ + public static function _handleJSCall(){ + // get our parameters + var numArgs = parseInt(_root._numArgs); + var jsArgs = new Array(); + for(var i = 0; i < numArgs; i++){ + var currentValue = _root["_" + i]; + jsArgs.push(currentValue); + } + + // get our function name + var functionName = _root._functionName; + + // now get the actual instance and method object to execute on, + // using our lookup table that was constructed by calls to + // addCallback on initialization + var instance = _callbacks["_" + functionName]._instance; + var method = _callbacks["_" + functionName]._method; + + // execute it + var results = method.apply(instance, jsArgs); + + // return the results + _root._returnResult = results; + } + + /** Called by the flash6_gateway.swf to indicate that it is loaded. */ + public static function _gatewayReady(){ + for(var i = 0; i < _callbacks.length; i++){ + fscommand("addCallback", _callbacks[i]); + } + call("dojo.flash.loaded"); + } + + /** + When JavaScript wants to communicate with Flash it simply sets + the Flash variable "_execute" to true; this method creates the + internal Movie Clip, called the Flash Runner, that makes this + magic happen. + */ + public static function _initializeFlashRunner(){ + // figure out where our Flash movie is + var swfLoc = DojoExternalInterface.dojoPath + "flash6_gateway.swf"; + + // load our gateway helper file + _root.createEmptyMovieClip("_flashRunner", 5000); + _root._flashRunner._lockroot = true; + _root._flashRunner.loadMovie(swfLoc); + } + + private static function getDojoPath(){ + var url = _root._url; + var start = url.indexOf("baseRelativePath=") + "baseRelativePath=".length; + var path = url.substring(start); + var end = path.indexOf("&"); + if(end != -1){ + path = path.substring(0, end); + } + return path; + } +} + +// vim:ts=4:noet:tw=0: Added: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash8/DojoExternalInterface.as URL: http://svn.apache.org/viewvc/geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash8/DojoExternalInterface.as?rev=794787&view=auto ============================================================================== --- geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash8/DojoExternalInterface.as (added) +++ geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash8/DojoExternalInterface.as Thu Jul 16 19:14:41 2009 @@ -0,0 +1,234 @@ +/* + 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 +*/ + +/** + A wrapper around Flash 8's ExternalInterface; DojoExternalInterface is needed so that we + can do a Flash 6 implementation of ExternalInterface, and be able + to support having a single codebase that uses DojoExternalInterface + across Flash versions rather than having two seperate source bases, + where one uses ExternalInterface and the other uses DojoExternalInterface. + + DojoExternalInterface class does a variety of optimizations to bypass ExternalInterface's + unbelievably bad performance so that we can have good performance + on Safari; see the blog post + http://codinginparadise.org/weblog/2006/02/how-to-speed-up-flash-8s.html + for details. + + @author Brad Neuberg, bkn3@columbia.edu +*/ +import flash.external.ExternalInterface; + +class DojoExternalInterface{ + public static var available:Boolean; + public static var dojoPath = ""; + + private static var flashMethods:Array = new Array(); + private static var numArgs:Number; + private static var argData:Array; + private static var resultData = null; + + public static function initialize(){ + // extract the dojo base path + DojoExternalInterface.dojoPath = DojoExternalInterface.getDojoPath(); + + // see if we need to do an express install + var install:ExpressInstall = new ExpressInstall(); + if(install.needsUpdate){ + install.init(); + } + + // register our callback functions + ExternalInterface.addCallback("startExec", DojoExternalInterface, startExec); + ExternalInterface.addCallback("setNumberArguments", DojoExternalInterface, + setNumberArguments); + ExternalInterface.addCallback("chunkArgumentData", DojoExternalInterface, + chunkArgumentData); + ExternalInterface.addCallback("exec", DojoExternalInterface, exec); + ExternalInterface.addCallback("getReturnLength", DojoExternalInterface, + getReturnLength); + ExternalInterface.addCallback("chunkReturnData", DojoExternalInterface, + chunkReturnData); + ExternalInterface.addCallback("endExec", DojoExternalInterface, endExec); + + // set whether communication is available + DojoExternalInterface.available = ExternalInterface.available; + DojoExternalInterface.call("loaded"); + } + + public static function addCallback(methodName:String, instance:Object, + method:Function) : Boolean{ + // register DojoExternalInterface methodName with it's instance + DojoExternalInterface.flashMethods[methodName] = instance; + + // tell JavaScript about DojoExternalInterface new method so we can create a proxy + ExternalInterface.call("dojo.flash.comm._addExternalInterfaceCallback", + methodName); + + return true; + } + + public static function call(methodName:String, + resultsCallback:Function) : Void{ + // we might have any number of optional arguments, so we have to + // pass them in dynamically; strip out the results callback + var parameters = new Array(); + for(var i = 0; i < arguments.length; i++){ + if(i != 1){ // skip the callback + parameters.push(arguments[i]); + } + } + + var results = ExternalInterface.call.apply(ExternalInterface, parameters); + + // immediately give the results back, since ExternalInterface is + // synchronous + if(resultsCallback != null && typeof resultsCallback != "undefined"){ + resultsCallback.call(null, results); + } + } + + /** + Called by Flash to indicate to JavaScript that we are ready to have + our Flash functions called. Calling loaded() + will fire the dojo.flash.loaded() event, so that JavaScript can know that + Flash has finished loading and adding its callbacks, and can begin to + interact with the Flash file. + */ + public static function loaded(){ + DojoExternalInterface.call("dojo.flash.loaded"); + } + + public static function startExec():Void{ + DojoExternalInterface.numArgs = null; + DojoExternalInterface.argData = null; + DojoExternalInterface.resultData = null; + } + + public static function setNumberArguments(numArgs):Void{ + DojoExternalInterface.numArgs = numArgs; + DojoExternalInterface.argData = new Array(DojoExternalInterface.numArgs); + } + + public static function chunkArgumentData(value, argIndex:Number):Void{ + //getURL("javascript:dojo.debug('FLASH: chunkArgumentData, value="+value+", argIndex="+argIndex+"')"); + var currentValue = DojoExternalInterface.argData[argIndex]; + if(currentValue == null || typeof currentValue == "undefined"){ + DojoExternalInterface.argData[argIndex] = value; + }else{ + DojoExternalInterface.argData[argIndex] += value; + } + } + + public static function exec(methodName):Void{ + // decode all of the arguments that were passed in + for(var i = 0; i < DojoExternalInterface.argData.length; i++){ + DojoExternalInterface.argData[i] = + DojoExternalInterface.decodeData(DojoExternalInterface.argData[i]); + } + + var instance = DojoExternalInterface.flashMethods[methodName]; + DojoExternalInterface.resultData = instance[methodName].apply( + instance, DojoExternalInterface.argData); + // encode the result data + DojoExternalInterface.resultData = + DojoExternalInterface.encodeData(DojoExternalInterface.resultData); + + //getURL("javascript:dojo.debug('FLASH: encoded result data="+DojoExternalInterface.resultData+"')"); + } + + public static function getReturnLength():Number{ + if(DojoExternalInterface.resultData == null || + typeof DojoExternalInterface.resultData == "undefined"){ + return 0; + } + var segments = Math.ceil(DojoExternalInterface.resultData.length / 1024); + return segments; + } + + public static function chunkReturnData(segment:Number):String{ + var numSegments = DojoExternalInterface.getReturnLength(); + var startCut = segment * 1024; + var endCut = segment * 1024 + 1024; + if(segment == (numSegments - 1)){ + endCut = segment * 1024 + DojoExternalInterface.resultData.length; + } + + var piece = DojoExternalInterface.resultData.substring(startCut, endCut); + + //getURL("javascript:dojo.debug('FLASH: chunking return piece="+piece+"')"); + + return piece; + } + + public static function endExec():Void{ + } + + private static function decodeData(data):String{ + // we have to use custom encodings for certain characters when passing + // them over; for example, passing a backslash over as //// from JavaScript + // to Flash doesn't work + data = DojoExternalInterface.replaceStr(data, "&custom_backslash;", "\\"); + + data = DojoExternalInterface.replaceStr(data, "\\\'", "\'"); + data = DojoExternalInterface.replaceStr(data, "\\\"", "\""); + + return data; + } + + private static function encodeData(data){ + //getURL("javascript:dojo.debug('inside flash, data before="+data+"')"); + + // double encode all entity values, or they will be mis-decoded + // by Flash when returned + data = DojoExternalInterface.replaceStr(data, "&", "&"); + + // certain XMLish characters break Flash's wire serialization for + // ExternalInterface; encode these into a custom encoding, rather than + // the standard entity encoding, because otherwise we won't be able to + // differentiate between our own encoding and any entity characters + // that are being used in the string itself + data = DojoExternalInterface.replaceStr(data, '<', '&custom_lt;'); + data = DojoExternalInterface.replaceStr(data, '>', '&custom_gt;'); + + // encode control characters and JavaScript delimiters + data = DojoExternalInterface.replaceStr(data, "\n", "\\n"); + data = DojoExternalInterface.replaceStr(data, "\r", "\\r"); + data = DojoExternalInterface.replaceStr(data, "\f", "\\f"); + data = DojoExternalInterface.replaceStr(data, "'", "\\'"); + data = DojoExternalInterface.replaceStr(data, '"', '\"'); + + //getURL("javascript:dojo.debug('inside flash, data after="+data+"')"); + return data; + } + + /** + Flash ActionScript has no String.replace method or support for + Regular Expressions! We roll our own very simple one. + */ + private static function replaceStr(inputStr:String, replaceThis:String, + withThis:String):String { + var splitStr = inputStr.split(replaceThis) + inputStr = splitStr.join(withThis) + return inputStr; + } + + private static function getDojoPath(){ + var url = _root._url; + var start = url.indexOf("baseRelativePath=") + "baseRelativePath=".length; + var path = url.substring(start); + var end = path.indexOf("&"); + if(end != -1){ + path = path.substring(0, end); + } + return path; + } +} + +// vim:ts=4:noet:tw=0: Added: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash8/ExpressInstall.as URL: http://svn.apache.org/viewvc/geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash8/ExpressInstall.as?rev=794787&view=auto ============================================================================== --- geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash8/ExpressInstall.as (added) +++ geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/flash/flash8/ExpressInstall.as Thu Jul 16 19:14:41 2009 @@ -0,0 +1,81 @@ +/* + 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 +*/ + +/** + * Based on the expressinstall.as class created by Geoff Stearns as part + * of the FlashObject library. + * + * Use this file to invoke the Macromedia Flash Player Express Install functionality + * This file is intended for use with the FlashObject embed script. You can download FlashObject + * and this file at the following URL: http://blog.deconcept.com/flashobject/ + * + * Usage: + * var ExpressInstall = new ExpressInstall(); + * + * // test to see if install is needed: + * if (ExpressInstall.needsUpdate) { // returns true if update is needed + * ExpressInstall.init(); // starts the update + * } + * + * NOTE: Your Flash movie must be at least 214px by 137px in order to use ExpressInstall. + * + */ + +class ExpressInstall { + public var needsUpdate:Boolean; + private var updater:MovieClip; + private var hold:MovieClip; + + public function ExpressInstall(){ + // does the user need to update? + this.needsUpdate = (_root.MMplayerType == undefined) ? false : true; + } + + public function init():Void{ + this.loadUpdater(); + } + + public function loadUpdater():Void { + System.security.allowDomain("fpdownload.macromedia.com"); + + // hope that nothing is at a depth of 10000000, you can change this depth if needed, but you want + // it to be on top of your content if you have any stuff on the first frame + this.updater = _root.createEmptyMovieClip("expressInstallHolder", 10000000); + + // register the callback so we know if they cancel or there is an error + var _self = this; + this.updater.installStatus = _self.onInstallStatus; + this.hold = this.updater.createEmptyMovieClip("hold", 1); + + // can't use movieClipLoader because it has to work in 6.0.65 + this.updater.onEnterFrame = function():Void { + if(typeof this.hold.startUpdate == 'function'){ + _self.initUpdater(); + this.onEnterFrame = null; + } + } + + var cacheBuster:Number = Math.random(); + + this.hold.loadMovie("http://fpdownload.macromedia.com/pub/flashplayer/" + +"update/current/swf/autoUpdater.swf?"+ cacheBuster); + } + + private function initUpdater():Void{ + this.hold.redirectURL = _root.MMredirectURL; + this.hold.MMplayerType = _root.MMplayerType; + this.hold.MMdoctitle = _root.MMdoctitle; + this.hold.startUpdate(); + } + + public function onInstallStatus(msg):Void{ + getURL("javascript:dojo.flash.install._onInstallStatus('"+msg+"')"); + } +} Added: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/Colorspace.js URL: http://svn.apache.org/viewvc/geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/Colorspace.js?rev=794787&view=auto ============================================================================== --- geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/Colorspace.js (added) +++ geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/Colorspace.js Thu Jul 16 19:14:41 2009 @@ -0,0 +1,723 @@ +/* + 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.gfx.Colorspace"); +dojo.require("dojo.lang.common"); +dojo.require("dojo.math.matrix"); +dojo.gfx.Colorspace = function () { + this.whitePoint = "D65"; + this.stdObserver = "10"; + this.chromaticAdaptationAlg = "bradford"; + this.RGBWorkingSpace = "s_rgb"; + this.useApproxCIELabMapping = 1; + this.chainMaps = {"RGB_to_xyY":["XYZ"], "xyY_to_RGB":["XYZ"], "RGB_to_Lab":["XYZ"], "Lab_to_RGB":["XYZ"], "RGB_to_LCHab":["XYZ", "Lab"], "LCHab_to_RGB":["Lab"], "xyY_to_Lab":["XYZ"], "Lab_to_xyY":["XYZ"], "XYZ_to_LCHab":["Lab"], "LCHab_to_XYZ":["Lab"], "xyY_to_LCHab":["XYZ", "Lab"], "LCHab_to_xyY":["Lab", "XYZ"], "RGB_to_Luv":["XYZ"], "Luv_to_RGB":["XYZ"], "xyY_to_Luv":["XYZ"], "Luv_to_xyY":["XYZ"], "Lab_to_Luv":["XYZ"], "Luv_to_Lab":["XYZ"], "LCHab_to_Luv":["Lab", "XYZ"], "Luv_to_LCHab":["XYZ", "Lab"], "RGB_to_LCHuv":["XYZ", "Luv"], "LCHuv_to_RGB":["Luv", "XYZ"], "XYZ_to_LCHuv":["Luv"], "LCHuv_to_XYZ":["Luv"], "xyY_to_LCHuv":["XYZ", "Luv"], "LCHuv_to_xyY":["Luv", "XYZ"], "Lab_to_LCHuv":["XYZ", "Luv"], "LCHuv_to_Lab":["Luv", "XYZ"], "LCHab_to_LCHuv":["Lab", "XYZ", "Luv"], "LCHuv_to_LCHab":["Luv", "XYZ", "Lab"], "XYZ_to_CMY":["RGB"], "CMY_to_XYZ":["RGB"], "xyY_to_CMY":["RGB"], "CMY_to_xyY":["RGB"], "Lab_to_CMY":["RGB"], "CMY_to_Lab":["RGB"], "LCHab_to_CMY":["RGB"], "CMY_to_L CHab":["RGB"], "Luv_to_CMY":["RGB"], "CMY_to_Luv":["RGB"], "LCHuv_to_CMY":["RGB"], "CMY_to_LCHuv":["RGB"], "XYZ_to_HSL":["RGB"], "HSL_to_XYZ":["RGB"], "xyY_to_HSL":["RGB"], "HSL_to_xyY":["RGB"], "Lab_to_HSL":["RGB"], "HSL_to_Lab":["RGB"], "LCHab_to_HSL":["RGB"], "HSL_to_LCHab":["RGB"], "Luv_to_HSL":["RGB"], "HSL_to_Luv":["RGB"], "LCHuv_to_HSL":["RGB"], "HSL_to_LCHuv":["RGB"], "CMY_to_HSL":["RGB"], "HSL_to_CMY":["RGB"], "CMYK_to_HSL":["RGB"], "HSL_to_CMYK":["RGB"], "XYZ_to_HSV":["RGB"], "HSV_to_XYZ":["RGB"], "xyY_to_HSV":["RGB"], "HSV_to_xyY":["RGB"], "Lab_to_HSV":["RGB"], "HSV_to_Lab":["RGB"], "LCHab_to_HSV":["RGB"], "HSV_to_LCHab":["RGB"], "Luv_to_HSV":["RGB"], "HSV_to_Luv":["RGB"], "LCHuv_to_HSV":["RGB"], "HSV_to_LCHuv":["RGB"], "CMY_to_HSV":["RGB"], "HSV_to_CMY":["RGB"], "CMYK_to_HSV":["RGB"], "HSV_to_CMYK":["RGB"], "HSL_to_HSV":["RGB"], "HSV_to_HSL":["RGB"], "XYZ_to_CMYK":["RGB"], "CMYK_to_XYZ":["RGB"], "xyY_to_CMYK":["RGB"], "CMYK_to_xyY":["RGB"], "Lab_to_CMYK":["RGB"], "CMYK_to_Lab":["RGB"], "LCHab_to_CMYK":["RGB"], "CMYK_to_LCHab":["RGB"], "Luv_to_CMYK":["RGB"], "CMYK_to_Luv":["RGB"], "LCHuv_to_CMYK":["RGB"], "CMYK_to_LCHuv":["RGB"]}; + return this; +}; +dojo.gfx.Colorspace.prototype.convert = function (col, model_from, model_to) { + var k = model_from + "_to_" + model_to; + if (this[k]) { + return this[k](col); + } else { + if (this.chainMaps[k]) { + var cur = model_from; + var models = this.chainMaps[k].concat(); + models.push(model_to); + for (var i = 0; i < models.length; i++) { + col = this.convert(col, cur, models[i]); + cur = models[i]; + } + return col; + } else { + dojo.debug("Can't convert from " + model_from + " to " + model_to); + } + } +}; +dojo.gfx.Colorspace.prototype.munge = function (keys, args) { + if (dojo.lang.isArray(args[0])) { + args = args[0]; + } + var out = new Array(); + for (var i = 0; i < keys.length; i++) { + out[keys.charAt(i)] = args[i]; + } + return out; +}; +dojo.gfx.Colorspace.prototype.getWhitePoint = function () { + var x = 0; + var y = 0; + var t = 0; + switch (this.stdObserver) { + case "2": + switch (this.whitePoint) { + case "E": + x = 1 / 3; + y = 1 / 3; + t = 5400; + break; + case "D50": + x = 0.34567; + y = 0.3585; + t = 5000; + break; + case "D55": + x = 0.33242; + y = 0.34743; + t = 5500; + break; + case "D65": + x = 0.31271; + y = 0.32902; + t = 6500; + break; + case "D75": + x = 0.29902; + y = 0.31485; + t = 7500; + break; + case "A": + x = 0.44757; + y = 0.40745; + t = 2856; + break; + case "B": + x = 0.34842; + y = 0.35161; + t = 4874; + break; + case "C": + x = 0.31006; + y = 0.31616; + t = 6774; + break; + case "9300": + x = 0.2848; + y = 0.2932; + t = 9300; + break; + case "F2": + x = 0.37207; + y = 0.37512; + t = 4200; + break; + case "F7": + x = 0.31285; + y = 0.32918; + t = 6500; + break; + case "F11": + x = 0.38054; + y = 0.37691; + t = 4000; + break; + default: + dojo.debug("White point " + this.whitePoint + " isn't defined for Std. Observer " + this.strObserver); + } + break; + case "10": + switch (this.whitePoint) { + case "E": + x = 1 / 3; + y = 1 / 3; + t = 5400; + break; + case "D50": + x = 0.34773; + y = 0.35952; + t = 5000; + break; + case "D55": + x = 0.33411; + y = 0.34877; + t = 5500; + break; + case "D65": + x = 0.31382; + y = 0.331; + t = 6500; + break; + case "D75": + x = 0.29968; + y = 0.3174; + t = 7500; + break; + case "A": + x = 0.45117; + y = 0.40594; + t = 2856; + break; + case "B": + x = 0.3498; + y = 0.3527; + t = 4874; + break; + case "C": + x = 0.31039; + y = 0.31905; + t = 6774; + break; + case "F2": + x = 0.37928; + y = 0.36723; + t = 4200; + break; + case "F7": + x = 0.31565; + y = 0.32951; + t = 6500; + break; + case "F11": + x = 0.38543; + y = 0.3711; + t = 4000; + break; + default: + dojo.debug("White point " + this.whitePoint + " isn't defined for Std. Observer " + this.strObserver); + } + break; + default: + dojo.debug("Std. Observer " + this.strObserver + " isn't defined"); + } + var z = 1 - x - y; + var wp = {"x":x, "y":y, "z":z, "t":t}; + wp.Y = 1; + var XYZ = this.xyY_to_XYZ([wp.x, wp.y, wp.Y]); + wp.X = XYZ[0]; + wp.Y = XYZ[1]; + wp.Z = XYZ[2]; + return wp; +}; +dojo.gfx.Colorspace.prototype.getPrimaries = function () { + var m = []; + switch (this.RGBWorkingSpace) { + case "adobe_rgb_1998": + m = [2.2, "D65", 0.64, 0.33, 0.297361, 0.21, 0.71, 0.627355, 0.15, 0.06, 0.075285]; + break; + case "apple_rgb": + m = [1.8, "D65", 0.625, 0.34, 0.244634, 0.28, 0.595, 0.672034, 0.155, 0.07, 0.083332]; + break; + case "best_rgb": + m = [2.2, "D50", 0.7347, 0.2653, 0.228457, 0.215, 0.775, 0.737352, 0.13, 0.035, 0.034191]; + break; + case "beta_rgb": + m = [2.2, "D50", 0.6888, 0.3112, 0.303273, 0.1986, 0.7551, 0.663786, 0.1265, 0.0352, 0.032941]; + break; + case "bruce_rgb": + m = [2.2, "D65", 0.64, 0.33, 0.240995, 0.28, 0.65, 0.683554, 0.15, 0.06, 0.075452]; + break; + case "cie_rgb": + m = [2.2, "E", 0.735, 0.265, 0.176204, 0.274, 0.717, 0.812985, 0.167, 0.009, 0.010811]; + break; + case "color_match_rgb": + m = [1.8, "D50", 0.63, 0.34, 0.274884, 0.295, 0.605, 0.658132, 0.15, 0.075, 0.066985]; + break; + case "don_rgb_4": + m = [2.2, "D50", 0.696, 0.3, 0.27835, 0.215, 0.765, 0.68797, 0.13, 0.035, 0.03368]; + break; + case "eci_rgb": + m = [1.8, "D50", 0.67, 0.33, 0.32025, 0.21, 0.71, 0.602071, 0.14, 0.08, 0.077679]; + break; + case "ekta_space_ps5": + m = [2.2, "D50", 0.695, 0.305, 0.260629, 0.26, 0.7, 0.734946, 0.11, 0.005, 0.004425]; + break; + case "ntsc_rgb": + m = [2.2, "C", 0.67, 0.33, 0.298839, 0.21, 0.71, 0.586811, 0.14, 0.08, 0.11435]; + break; + case "pal_secam_rgb": + m = [2.2, "D65", 0.64, 0.33, 0.222021, 0.29, 0.6, 0.706645, 0.15, 0.06, 0.071334]; + break; + case "pro_photo_rgb": + m = [1.8, "D50", 0.7347, 0.2653, 0.28804, 0.1596, 0.8404, 0.711874, 0.0366, 0.0001, 0.000086]; + break; + case "smpte-c_rgb": + m = [2.2, "D65", 0.63, 0.34, 0.212395, 0.31, 0.595, 0.701049, 0.155, 0.07, 0.086556]; + break; + case "s_rgb": + m = [2.2, "D65", 0.64, 0.33, 0.212656, 0.3, 0.6, 0.715158, 0.15, 0.06, 0.072186]; + break; + case "wide_gamut_rgb": + m = [2.2, "D50", 0.735, 0.265, 0.258187, 0.115, 0.826, 0.724938, 0.157, 0.018, 0.016875]; + break; + default: + dojo.debug("RGB working space " + this.RGBWorkingSpace + " isn't defined"); + } + var p = {name:this.RGBWorkingSpace, gamma:m[0], wp:m[1], xr:m[2], yr:m[3], Yr:m[4], xg:m[5], yg:m[6], Yg:m[7], xb:m[8], yb:m[9], Yb:m[10]}; + if (p.wp != this.whitePoint) { + var r = this.XYZ_to_xyY(this.chromaticAdaptation(this.xyY_to_XYZ([p.xr, p.yr, p.Yr]), p.wp, this.whitePoint)); + var g = this.XYZ_to_xyY(this.chromaticAdaptation(this.xyY_to_XYZ([p.xg, p.yg, p.Yg]), p.wp, this.whitePoint)); + var b = this.XYZ_to_xyY(this.chromaticAdaptation(this.xyY_to_XYZ([p.xb, p.yb, p.Yb]), p.wp, this.whitePoint)); + p.xr = r[0]; + p.yr = r[1]; + p.Yr = r[2]; + p.xg = g[0]; + p.yg = g[1]; + p.Yg = g[2]; + p.xb = b[0]; + p.yb = b[1]; + p.Yb = b[2]; + p.wp = this.whitePoint; + } + p.zr = 1 - p.xr - p.yr; + p.zg = 1 - p.xg - p.yg; + p.zb = 1 - p.xb - p.yb; + return p; +}; +dojo.gfx.Colorspace.prototype.epsilon = function () { + return this.useApproxCIELabMapping ? 0.008856 : 216 / 24289; +}; +dojo.gfx.Colorspace.prototype.kappa = function () { + return this.useApproxCIELabMapping ? 903.3 : 24389 / 27; +}; +dojo.gfx.Colorspace.prototype.XYZ_to_xyY = function () { + var src = this.munge("XYZ", arguments); + var sum = src.X + src.Y + src.Z; + if (sum == 0) { + var wp = this.getWhitePoint(); + var x = wp.x; + var y = wp.y; + } else { + var x = src.X / sum; + var y = src.Y / sum; + } + var Y = src.Y; + return [x, y, Y]; +}; +dojo.gfx.Colorspace.prototype.xyY_to_XYZ = function () { + var src = this.munge("xyY", arguments); + if (src.y == 0) { + var X = 0; + var Y = 0; + var Z = 0; + } else { + var X = (src.x * src.Y) / src.y; + var Y = src.Y; + var Z = ((1 - src.x - src.y) * src.Y) / src.y; + } + return [X, Y, Z]; +}; +dojo.gfx.Colorspace.prototype.RGB_to_XYZ = function () { + var src = this.munge("RGB", arguments); + var m = this.getRGB_XYZ_Matrix(); + var pr = this.getPrimaries(); + if (this.RGBWorkingSpace == "s_rgb") { + var r = (src.R > 0.04045) ? Math.pow(((src.R + 0.055) / 1.055), 2.4) : src.R / 12.92; + var g = (src.G > 0.04045) ? Math.pow(((src.G + 0.055) / 1.055), 2.4) : src.G / 12.92; + var b = (src.B > 0.04045) ? Math.pow(((src.B + 0.055) / 1.055), 2.4) : src.B / 12.92; + } else { + var r = Math.pow(src.R, pr.gamma); + var g = Math.pow(src.G, pr.gamma); + var b = Math.pow(src.B, pr.gamma); + } + var XYZ = dojo.math.matrix.multiply([[r, g, b]], m); + return [XYZ[0][0], XYZ[0][1], XYZ[0][2]]; +}; +dojo.gfx.Colorspace.prototype.XYZ_to_RGB = function () { + var src = this.munge("XYZ", arguments); + var mi = this.getXYZ_RGB_Matrix(); + var pr = this.getPrimaries(); + var rgb = dojo.math.matrix.multiply([[src.X, src.Y, src.Z]], mi); + var r = rgb[0][0]; + var g = rgb[0][1]; + var b = rgb[0][2]; + if (this.RGBWorkingSpace == "s_rgb") { + var R = (r > 0.0031308) ? (1.055 * Math.pow(r, 1 / 2.4)) - 0.055 : 12.92 * r; + var G = (g > 0.0031308) ? (1.055 * Math.pow(g, 1 / 2.4)) - 0.055 : 12.92 * g; + var B = (b > 0.0031308) ? (1.055 * Math.pow(b, 1 / 2.4)) - 0.055 : 12.92 * b; + } else { + var R = Math.pow(r, 1 / pr.gamma); + var G = Math.pow(g, 1 / pr.gamma); + var B = Math.pow(b, 1 / pr.gamma); + } + return [R, G, B]; +}; +dojo.gfx.Colorspace.prototype.XYZ_to_Lab = function () { + var src = this.munge("XYZ", arguments); + var wp = this.getWhitePoint(); + var xr = src.X / wp.X; + var yr = src.Y / wp.Y; + var zr = src.Z / wp.Z; + var fx = (xr > this.epsilon()) ? Math.pow(xr, 1 / 3) : (this.kappa() * xr + 16) / 116; + var fy = (yr > this.epsilon()) ? Math.pow(yr, 1 / 3) : (this.kappa() * yr + 16) / 116; + var fz = (zr > this.epsilon()) ? Math.pow(zr, 1 / 3) : (this.kappa() * zr + 16) / 116; + var L = 116 * fy - 16; + var a = 500 * (fx - fy); + var b = 200 * (fy - fz); + return [L, a, b]; +}; +dojo.gfx.Colorspace.prototype.Lab_to_XYZ = function () { + var src = this.munge("Lab", arguments); + var wp = this.getWhitePoint(); + var yr = (src.L > (this.kappa() * this.epsilon())) ? Math.pow((src.L + 16) / 116, 3) : src.L / this.kappa(); + var fy = (yr > this.epsilon()) ? (src.L + 16) / 116 : (this.kappa() * yr + 16) / 116; + var fx = (src.a / 500) + fy; + var fz = fy - (src.b / 200); + var fxcube = Math.pow(fx, 3); + var fzcube = Math.pow(fz, 3); + var xr = (fxcube > this.epsilon()) ? fxcube : (116 * fx - 16) / this.kappa(); + var zr = (fzcube > this.epsilon()) ? fzcube : (116 * fz - 16) / this.kappa(); + var X = xr * wp.X; + var Y = yr * wp.Y; + var Z = zr * wp.Z; + return [X, Y, Z]; +}; +dojo.gfx.Colorspace.prototype.Lab_to_LCHab = function () { + var src = this.munge("Lab", arguments); + var L = src.L; + var C = Math.pow(src.a * src.a + src.b * src.b, 0.5); + var H = Math.atan2(src.b, src.a) * (180 / Math.PI); + if (H < 0) { + H += 360; + } + if (H > 360) { + H -= 360; + } + return [L, C, H]; +}; +dojo.gfx.Colorspace.prototype.LCHab_to_Lab = function () { + var src = this.munge("LCH", arguments); + var H_rad = src.H * (Math.PI / 180); + var L = src.L; + var a = src.C / Math.pow(Math.pow(Math.tan(H_rad), 2) + 1, 0.5); + if ((90 < src.H) && (src.H < 270)) { + a = -a; + } + var b = Math.pow(Math.pow(src.C, 2) - Math.pow(a, 2), 0.5); + if (src.H > 180) { + b = -b; + } + return [L, a, b]; +}; +dojo.gfx.Colorspace.prototype.chromaticAdaptation = function (col, src_w, dst_w) { + col = this.munge("XYZ", [col]); + var old_wp = this.whitePoint; + this.whitePoint = src_w; + var wp_src = this.getWhitePoint(); + this.whitePoint = dst_w; + var wp_dst = this.getWhitePoint(); + this.whitePoint = old_wp; + switch (this.chromaticAdaptationAlg) { + case "xyz_scaling": + var ma = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]; + var mai = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]; + break; + case "bradford": + var ma = [[0.8951, -0.7502, 0.0389], [0.2664, 1.7135, -0.0685], [-0.1614, 0.0367, 1.0296]]; + var mai = [[0.986993, 0.432305, -0.008529], [-0.147054, 0.51836, 0.040043], [0.159963, 0.049291, 0.968487]]; + break; + case "von_kries": + var ma = [[0.40024, -0.2263, 0], [0.7076, 1.16532, 0], [-0.08081, 0.0457, 0.91822]]; + var mai = [[1.859936, 0.361191, 0], [-1.129382, 0.638812, 0], [0.219897, -0.000006, 1.089064]]; + break; + default: + dojo.debug("The " + this.chromaticAdaptationAlg + " chromatic adaptation algorithm matricies are not defined"); + } + var domain_src = dojo.math.matrix.multiply([[wp_src.x, wp_src.y, wp_src.z]], ma); + var domain_dst = dojo.math.matrix.multiply([[wp_dst.x, wp_dst.y, wp_dst.z]], ma); + var centre = [[domain_dst[0][0] / domain_src[0][0], 0, 0], [0, domain_dst[0][1] / domain_src[0][1], 0], [0, 0, domain_dst[0][2] / domain_src[0][2]]]; + var m = dojo.math.matrix.multiply(dojo.math.matrix.multiply(ma, centre), mai); + var dst = dojo.math.matrix.multiply([[col.X, col.Y, col.Z]], m); + return dst[0]; +}; +dojo.gfx.Colorspace.prototype.getRGB_XYZ_Matrix = function () { + var wp = this.getWhitePoint(); + var pr = this.getPrimaries(); + var Xr = pr.xr / pr.yr; + var Yr = 1; + var Zr = (1 - pr.xr - pr.yr) / pr.yr; + var Xg = pr.xg / pr.yg; + var Yg = 1; + var Zg = (1 - pr.xg - pr.yg) / pr.yg; + var Xb = pr.xb / pr.yb; + var Yb = 1; + var Zb = (1 - pr.xb - pr.yb) / pr.yb; + var m1 = [[Xr, Yr, Zr], [Xg, Yg, Zg], [Xb, Yb, Zb]]; + var m2 = [[wp.X, wp.Y, wp.Z]]; + var sm = dojo.math.matrix.multiply(m2, dojo.math.matrix.inverse(m1)); + var Sr = sm[0][0]; + var Sg = sm[0][1]; + var Sb = sm[0][2]; + var m4 = [[Sr * Xr, Sr * Yr, Sr * Zr], [Sg * Xg, Sg * Yg, Sg * Zg], [Sb * Xb, Sb * Yb, Sb * Zb]]; + return m4; +}; +dojo.gfx.Colorspace.prototype.getXYZ_RGB_Matrix = function () { + var m = this.getRGB_XYZ_Matrix(); + return dojo.math.matrix.inverse(m); +}; +dojo.gfx.Colorspace.prototype.XYZ_to_Luv = function () { + var src = this.munge("XYZ", arguments); + var wp = this.getWhitePoint(); + var ud = (4 * src.X) / (src.X + 15 * src.Y + 3 * src.Z); + var vd = (9 * src.Y) / (src.X + 15 * src.Y + 3 * src.Z); + var udr = (4 * wp.X) / (wp.X + 15 * wp.Y + 3 * wp.Z); + var vdr = (9 * wp.Y) / (wp.X + 15 * wp.Y + 3 * wp.Z); + var yr = src.Y / wp.Y; + var L = (yr > this.epsilon()) ? 116 * Math.pow(yr, 1 / 3) - 16 : this.kappa() * yr; + var u = 13 * L * (ud - udr); + var v = 13 * L * (vd - vdr); + return [L, u, v]; +}; +dojo.gfx.Colorspace.prototype.Luv_to_XYZ = function () { + var src = this.munge("Luv", arguments); + var wp = this.getWhitePoint(); + var uz = (4 * wp.X) / (wp.X + 15 * wp.Y + 3 * wp.Z); + var vz = (9 * wp.Y) / (wp.X + 15 * wp.Y + 3 * wp.Z); + var Y = (src.L > this.kappa() * this.epsilon()) ? Math.pow((src.L + 16) / 116, 3) : src.L / this.kappa(); + var a = (1 / 3) * (((52 * src.L) / (src.u + 13 * src.L * uz)) - 1); + var b = -5 * Y; + var c = -(1 / 3); + var d = Y * (((39 * src.L) / (src.v + 13 * src.L * vz)) - 5); + var X = (d - b) / (a - c); + var Z = X * a + b; + return [X, Y, Z]; +}; +dojo.gfx.Colorspace.prototype.Luv_to_LCHuv = function () { + var src = this.munge("Luv", arguments); + var L = src.L; + var C = Math.pow(src.u * src.u + src.v * src.v, 0.5); + var H = Math.atan2(src.v, src.u) * (180 / Math.PI); + if (H < 0) { + H += 360; + } + if (H > 360) { + H -= 360; + } + return [L, C, H]; +}; +dojo.gfx.Colorspace.prototype.LCHuv_to_Luv = function () { + var src = this.munge("LCH", arguments); + var H_rad = src.H * (Math.PI / 180); + var L = src.L; + var u = src.C / Math.pow(Math.pow(Math.tan(H_rad), 2) + 1, 0.5); + var v = Math.pow(src.C * src.C - u * u, 0.5); + if ((90 < src.H) && (src.H < 270)) { + u *= -1; + } + if (src.H > 180) { + v *= -1; + } + return [L, u, v]; +}; +dojo.gfx.Colorspace.colorTemp_to_whitePoint = function (T) { + if (T < 4000) { + dojo.debug("Can't find a white point for temperatures under 4000K"); + return [0, 0]; + } + if (T > 25000) { + dojo.debug("Can't find a white point for temperatures over 25000K"); + return [0, 0]; + } + var T1 = T; + var T2 = T * T; + var T3 = T2 * T; + var ten9 = Math.pow(10, 9); + var ten6 = Math.pow(10, 6); + var ten3 = Math.pow(10, 3); + if (T <= 7000) { + var x = (-4.607 * ten9 / T3) + (2.9678 * ten6 / T2) + (0.09911 * ten3 / T) + 0.244063; + } else { + var x = (-2.0064 * ten9 / T3) + (1.9018 * ten6 / T2) + (0.24748 * ten3 / T) + 0.23704; + } + var y = -3 * x * x + 2.87 * x - 0.275; + return [x, y]; +}; +dojo.gfx.Colorspace.prototype.RGB_to_CMY = function () { + var src = this.munge("RGB", arguments); + var C = 1 - src.R; + var M = 1 - src.G; + var Y = 1 - src.B; + return [C, M, Y]; +}; +dojo.gfx.Colorspace.prototype.CMY_to_RGB = function () { + var src = this.munge("CMY", arguments); + var R = 1 - src.C; + var G = 1 - src.M; + var B = 1 - src.Y; + return [R, G, B]; +}; +dojo.gfx.Colorspace.prototype.RGB_to_CMYK = function () { + var src = this.munge("RGB", arguments); + var K = Math.min(1 - src.R, 1 - src.G, 1 - src.B); + var C = (1 - src.R - K) / (1 - K); + var M = (1 - src.G - K) / (1 - K); + var Y = (1 - src.B - K) / (1 - K); + return [C, M, Y, K]; +}; +dojo.gfx.Colorspace.prototype.CMYK_to_RGB = function () { + var src = this.munge("CMYK", arguments); + var R = 1 - Math.min(1, src.C * (1 - src.K) + src.K); + var G = 1 - Math.min(1, src.M * (1 - src.K) + src.K); + var B = 1 - Math.min(1, src.Y * (1 - src.K) + src.K); + return [R, G, B]; +}; +dojo.gfx.Colorspace.prototype.CMY_to_CMYK = function () { + var src = this.munge("CMY", arguments); + var K = Math.min(src.C, src.M, src.Y); + var C = (src.C - K) / (1 - K); + var M = (src.M - K) / (1 - K); + var Y = (src.Y - K) / (1 - K); + return [C, M, Y, K]; +}; +dojo.gfx.Colorspace.prototype.CMYK_to_CMY = function () { + var src = this.munge("CMYK", arguments); + var C = Math.min(1, src.C * (1 - src.K) + src.K); + var M = Math.min(1, src.M * (1 - src.K) + src.K); + var Y = Math.min(1, src.Y * (1 - src.K) + src.K); + return [C, M, Y]; +}; +dojo.gfx.Colorspace.prototype.RGB_to_HSV = function () { + var src = this.munge("RGB", arguments); + var min = Math.min(src.R, src.G, src.B); + var V = Math.max(src.R, src.G, src.B); + var delta = V - min; + var H = null; + var S = (V == 0) ? 0 : delta / V; + if (S == 0) { + H = 0; + } else { + if (src.R == V) { + H = 60 * (src.G - src.B) / delta; + } else { + if (src.G == V) { + H = 120 + 60 * (src.B - src.R) / delta; + } else { + if (src.B == V) { + H = 240 + 60 * (src.R - src.G) / delta; + } + } + } + if (H < 0) { + H += 360; + } + } + H = (H == 0) ? 360 : H; + return [H, S, V]; +}; +dojo.gfx.Colorspace.prototype.HSV_to_RGB = function () { + var src = this.munge("HSV", arguments); + if (src.H == 360) { + src.H = 0; + } + var r = null; + var g = null; + var b = null; + if (src.S == 0) { + var R = src.V; + var G = src.V; + var B = src.V; + } else { + var hTemp = src.H / 60; + var i = Math.floor(hTemp); + var f = hTemp - i; + var p = src.V * (1 - src.S); + var q = src.V * (1 - (src.S * f)); + var t = src.V * (1 - (src.S * (1 - f))); + switch (i) { + case 0: + R = src.V; + G = t; + B = p; + break; + case 1: + R = q; + G = src.V; + B = p; + break; + case 2: + R = p; + G = src.V; + B = t; + break; + case 3: + R = p; + G = q; + B = src.V; + break; + case 4: + R = t; + G = p; + B = src.V; + break; + case 5: + R = src.V; + G = p; + B = q; + break; + } + } + return [R, G, B]; +}; +dojo.gfx.Colorspace.prototype.RGB_to_HSL = function () { + var src = this.munge("RGB", arguments); + var min = Math.min(src.R, src.G, src.B); + var max = Math.max(src.R, src.G, src.B); + var delta = max - min; + var H = 0; + var S = 0; + var L = (min + max) / 2; + if ((L > 0) && (L < 1)) { + S = delta / ((L < 0.5) ? (2 * L) : (2 - 2 * L)); + } + if (delta > 0) { + if ((max == src.R) && (max != src.G)) { + H += (src.G - src.B) / delta; + } + if ((max == src.G) && (max != src.B)) { + H += (2 + (src.B - src.R) / delta); + } + if ((max == src.B) && (max != src.R)) { + H += (4 + (src.R - src.G) / delta); + } + H *= 60; + } + H = (H == 0) ? 360 : H; + return [H, S, L]; +}; +dojo.gfx.Colorspace.prototype.HSL_to_RGB = function () { + var src = this.munge("HSL", arguments); + while (src.H < 0) { + src.H += 360; + } + while (src.H >= 360) { + src.H -= 360; + } + var R = 0; + var G = 0; + var B = 0; + if (src.H < 120) { + R = (120 - src.H) / 60; + G = src.H / 60; + B = 0; + } else { + if (src.H < 240) { + R = 0; + G = (240 - src.H) / 60; + B = (src.H - 120) / 60; + } else { + R = (src.H - 240) / 60; + G = 0; + B = (360 - src.H) / 60; + } + } + R = 2 * src.S * Math.min(R, 1) + (1 - src.S); + G = 2 * src.S * Math.min(G, 1) + (1 - src.S); + B = 2 * src.S * Math.min(B, 1) + (1 - src.S); + if (src.L < 0.5) { + R = src.L * R; + G = src.L * G; + B = src.L * B; + } else { + R = (1 - src.L) * R + 2 * src.L - 1; + G = (1 - src.L) * G + 2 * src.L - 1; + B = (1 - src.L) * B + 2 * src.L - 1; + } + return [R, G, B]; +}; + Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/Colorspace.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/Colorspace.js ------------------------------------------------------------------------------ svn:keywords = Date Revision Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/Colorspace.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/__package__.js URL: http://svn.apache.org/viewvc/geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/__package__.js?rev=794787&view=auto ============================================================================== --- geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/__package__.js (added) +++ geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/__package__.js Thu Jul 16 19:14:41 2009 @@ -0,0 +1,17 @@ +/* + 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.kwCompoundRequire({common:["dojo.gfx.color", "dojo.gfx.matrix", "dojo.gfx.common"]}); +dojo.requireIf(dojo.render.svg.capable, "dojo.gfx.svg"); +dojo.requireIf(dojo.render.vml.capable, "dojo.gfx.vml"); +dojo.provide("dojo.gfx.*"); + Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/__package__.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/__package__.js ------------------------------------------------------------------------------ svn:keywords = Date Revision Propchange: geronimo/external/trunk/geronimo-dojo-0.4.3/src/main/webapp/src/gfx/__package__.js ------------------------------------------------------------------------------ svn:mime-type = text/plain