diff options
Diffstat (limited to 'library/ajaxchat/chat/js/FABridge.js')
| -rw-r--r-- | library/ajaxchat/chat/js/FABridge.js | 591 |
1 files changed, 591 insertions, 0 deletions
diff --git a/library/ajaxchat/chat/js/FABridge.js b/library/ajaxchat/chat/js/FABridge.js new file mode 100644 index 000000000..59424573b --- /dev/null +++ b/library/ajaxchat/chat/js/FABridge.js @@ -0,0 +1,591 @@ +/*
+/*
+Copyright 2006 Adobe Systems Incorporated
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+
+
+/*
+ * The Bridge class, responsible for navigating AS instances
+ */
+function FABridge(target,bridgeName)
+{
+ this.target = target;
+ this.remoteTypeCache = {};
+ this.remoteInstanceCache = {};
+ this.remoteFunctionCache = {};
+ this.localFunctionCache = {};
+ this.bridgeID = FABridge.nextBridgeID++;
+ this.name = bridgeName;
+ this.nextLocalFuncID = 0;
+ FABridge.instances[this.name] = this;
+ FABridge.idMap[this.bridgeID] = this;
+
+ return this;
+}
+
+// type codes for packed values
+FABridge.TYPE_ASINSTANCE = 1;
+FABridge.TYPE_ASFUNCTION = 2;
+
+FABridge.TYPE_JSFUNCTION = 3;
+FABridge.TYPE_ANONYMOUS = 4;
+
+FABridge.initCallbacks = {}
+
+FABridge.argsToArray = function(args)
+{
+ var result = [];
+ for (var i = 0; i < args.length; i++)
+ {
+ result[i] = args[i];
+ }
+ return result;
+}
+
+function instanceFactory(objID)
+{
+ this.fb_instance_id = objID;
+ return this;
+}
+
+function FABridge__invokeJSFunction(args)
+{
+ var funcID = args[0];
+ var throughArgs = args.concat();//FABridge.argsToArray(arguments);
+ throughArgs.shift();
+
+ var bridge = FABridge.extractBridgeFromID(funcID);
+ return bridge.invokeLocalFunction(funcID, throughArgs);
+}
+
+FABridge.addInitializationCallback = function(bridgeName, callback)
+{
+ var inst = FABridge.instances[bridgeName];
+ if (inst != undefined)
+ {
+ callback.call(inst);
+ return;
+ }
+
+ var callbackList = FABridge.initCallbacks[bridgeName];
+ if(callbackList == null)
+ {
+ FABridge.initCallbacks[bridgeName] = callbackList = [];
+ }
+
+ callbackList.push(callback);
+}
+
+function FABridge__bridgeInitialized(bridgeName) {
+ var objects = document.getElementsByTagName("object");
+ var ol = objects.length;
+ var activeObjects = [];
+ if (ol > 0) {
+ for (var i = 0; i < ol; i++) {
+ if (typeof objects[i].SetVariable != "undefined") {
+ activeObjects[activeObjects.length] = objects[i];
+ }
+ }
+ }
+ var embeds = document.getElementsByTagName("embed");
+ var el = embeds.length;
+ var activeEmbeds = [];
+ if (el > 0) {
+ for (var j = 0; j < el; j++) {
+ if (typeof embeds[j].SetVariable != "undefined") {
+ activeEmbeds[activeEmbeds.length] = embeds[j];
+ }
+ }
+ }
+ var aol = activeObjects.length;
+ var ael = activeEmbeds.length;
+ var searchStr = "bridgeName="+ bridgeName;
+ if ((aol == 1 && !ael) || (aol == 1 && ael == 1)) {
+ FABridge.attachBridge(activeObjects[0], bridgeName);
+ }
+ else if (ael == 1 && !aol) {
+ FABridge.attachBridge(activeEmbeds[0], bridgeName);
+ }
+ else {
+ var flash_found = false;
+ if (aol > 1) {
+ for (var k = 0; k < aol; k++) {
+ var params = activeObjects[k].childNodes;
+ for (var l = 0; l < params.length; l++) {
+ var param = params[l];
+ if (param.nodeType == 1 && param.tagName.toLowerCase() == "param" && param["name"].toLowerCase() == "flashvars" && param["value"].indexOf(searchStr) >= 0) {
+ FABridge.attachBridge(activeObjects[k], bridgeName);
+ flash_found = true;
+ break;
+ }
+ }
+ if (flash_found) {
+ break;
+ }
+ }
+ }
+ if (!flash_found && ael > 1) {
+ for (var m = 0; m < ael; m++) {
+ var flashVars = activeEmbeds[m].attributes.getNamedItem("flashVars").nodeValue;
+ if (flashVars.indexOf(searchStr) >= 0) {
+ FABridge.attachBridge(activeEmbeds[m], bridgeName);
+ break;
+ }
+ }
+ }
+ }
+ return true;
+}
+
+// used to track multiple bridge instances, since callbacks from AS are global across the page.
+
+FABridge.nextBridgeID = 0;
+FABridge.instances = {};
+FABridge.idMap = {};
+FABridge.refCount = 0;
+
+FABridge.extractBridgeFromID = function(id)
+{
+ var bridgeID = (id >> 16);
+ return FABridge.idMap[bridgeID];
+}
+
+FABridge.attachBridge = function(instance, bridgeName)
+{
+ var newBridgeInstance = new FABridge(instance, bridgeName);
+
+ FABridge[bridgeName] = newBridgeInstance;
+
+/* FABridge[bridgeName] = function() {
+ return newBridgeInstance.root();
+ }
+*/
+ var callbacks = FABridge.initCallbacks[bridgeName];
+ if (callbacks == null)
+ {
+ return;
+ }
+ for (var i = 0; i < callbacks.length; i++)
+ {
+ callbacks[i].call(newBridgeInstance);
+ }
+ delete FABridge.initCallbacks[bridgeName]
+}
+
+// some methods can't be proxied. You can use the explicit get,set, and call methods if necessary.
+
+FABridge.blockedMethods =
+{
+ toString: true,
+ get: true,
+ set: true,
+ call: true
+};
+
+FABridge.prototype =
+{
+
+
+// bootstrapping
+
+ root: function()
+ {
+ return this.deserialize(this.target.getRoot());
+ },
+//clears all of the AS objects in the cache maps
+ releaseASObjects: function()
+ {
+ return this.target.releaseASObjects();
+ },
+//clears a specific object in AS from the type maps
+ releaseNamedASObject: function(value)
+ {
+ if(typeof(value) != "object")
+ {
+ return false;
+ }
+ else
+ {
+ var ret = this.target.releaseNamedASObject(value.fb_instance_id);
+ return ret;
+ }
+ },
+//create a new AS Object
+ create: function(className)
+ {
+ return this.deserialize(this.target.create(className));
+ },
+
+
+ // utilities
+
+ makeID: function(token)
+ {
+ return (this.bridgeID << 16) + token;
+ },
+
+
+ // low level access to the flash object
+
+//get a named property from an AS object
+ getPropertyFromAS: function(objRef, propName)
+ {
+ if (FABridge.refCount > 0)
+ {
+ throw new Error("You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.");
+ }
+ else
+ {
+ FABridge.refCount++;
+ retVal = this.target.getPropFromAS(objRef, propName);
+ retVal = this.handleError(retVal);
+ FABridge.refCount--;
+ return retVal;
+ }
+ },
+//set a named property on an AS object
+ setPropertyInAS: function(objRef,propName, value)
+ {
+ if (FABridge.refCount > 0)
+ {
+ throw new Error("You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.");
+ }
+ else
+ {
+ FABridge.refCount++;
+ retVal = this.target.setPropInAS(objRef,propName, this.serialize(value));
+ retVal = this.handleError(retVal);
+ FABridge.refCount--;
+ return retVal;
+ }
+ },
+
+//call an AS function
+ callASFunction: function(funcID, args)
+ {
+ if (FABridge.refCount > 0)
+ {
+ throw new Error("You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.");
+ }
+ else
+ {
+ FABridge.refCount++;
+ retVal = this.target.invokeASFunction(funcID, this.serialize(args));
+ retVal = this.handleError(retVal);
+ FABridge.refCount--;
+ return retVal;
+ }
+ },
+//call a method on an AS object
+ callASMethod: function(objID, funcName, args)
+ {
+ if (FABridge.refCount > 0)
+ {
+ throw new Error("You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.");
+ }
+ else
+ {
+ FABridge.refCount++;
+ args = this.serialize(args);
+ retVal = this.target.invokeASMethod(objID, funcName, args);
+ retVal = this.handleError(retVal);
+ FABridge.refCount--;
+ return retVal;
+ }
+ },
+
+ // responders to remote calls from flash
+
+ //callback from flash that executes a local JS function
+ //used mostly when setting js functions as callbacks on events
+ invokeLocalFunction: function(funcID, args)
+ {
+ var result;
+ var func = this.localFunctionCache[funcID];
+
+ if(func != undefined)
+ {
+ result = this.serialize(func.apply(null, this.deserialize(args)));
+ }
+
+ return result;
+ },
+
+ // Object Types and Proxies
+
+ // accepts an object reference, returns a type object matching the obj reference.
+ getTypeFromName: function(objTypeName)
+ {
+ return this.remoteTypeCache[objTypeName];
+ },
+ //create an AS proxy for the given object ID and type
+ createProxy: function(objID, typeName)
+ {
+ var objType = this.getTypeFromName(typeName);
+ instanceFactory.prototype = objType;
+ var instance = new instanceFactory(objID);
+ this.remoteInstanceCache[objID] = instance;
+ return instance;
+ },
+ //return the proxy associated with the given object ID
+ getProxy: function(objID)
+ {
+ return this.remoteInstanceCache[objID];
+ },
+
+ // accepts a type structure, returns a constructed type
+ addTypeDataToCache: function(typeData)
+ {
+ newType = new ASProxy(this, typeData.name);
+ var accessors = typeData.accessors;
+ for (var i = 0; i < accessors.length; i++)
+ {
+ this.addPropertyToType(newType, accessors[i]);
+ }
+
+ var methods = typeData.methods;
+ for (var i = 0; i < methods.length; i++)
+ {
+ if (FABridge.blockedMethods[methods[i]] == undefined)
+ {
+ this.addMethodToType(newType, methods[i]);
+ }
+ }
+
+
+ this.remoteTypeCache[newType.typeName] = newType;
+ return newType;
+ },
+
+ //add a property to a typename; used to define the properties that can be called on an AS proxied object
+ addPropertyToType: function(ty, propName)
+ {
+ var c = propName.charAt(0);
+ var setterName;
+ var getterName;
+ if(c >= "a" && c <= "z")
+ {
+ getterName = "get" + c.toUpperCase() + propName.substr(1);
+ setterName = "set" + c.toUpperCase() + propName.substr(1);
+ }
+ else
+ {
+ getterName = "get" + propName;
+ setterName = "set" + propName;
+ }
+ ty[setterName] = function(val)
+ {
+ this.bridge.setPropertyInAS(this.fb_instance_id, propName, val);
+ }
+ ty[getterName] = function()
+ {
+ return this.bridge.deserialize(this.bridge.getPropertyFromAS(this.fb_instance_id, propName));
+ }
+ },
+
+ //add a method to a typename; used to define the methods that can be callefd on an AS proxied object
+ addMethodToType: function(ty, methodName)
+ {
+ ty[methodName] = function()
+ {
+ return this.bridge.deserialize(this.bridge.callASMethod(this.fb_instance_id, methodName, FABridge.argsToArray(arguments)));
+ }
+ },
+
+ // Function Proxies
+
+ //returns the AS proxy for the specified function ID
+ getFunctionProxy: function(funcID)
+ {
+ var bridge = this;
+ if (this.remoteFunctionCache[funcID] == null)
+ {
+ this.remoteFunctionCache[funcID] = function()
+ {
+ bridge.callASFunction(funcID, FABridge.argsToArray(arguments));
+ }
+ }
+ return this.remoteFunctionCache[funcID];
+ },
+
+ //reutrns the ID of the given function; if it doesnt exist it is created and added to the local cache
+ getFunctionID: function(func)
+ {
+ if (func.__bridge_id__ == undefined)
+ {
+ func.__bridge_id__ = this.makeID(this.nextLocalFuncID++);
+ this.localFunctionCache[func.__bridge_id__] = func;
+ }
+ return func.__bridge_id__;
+ },
+
+ // serialization / deserialization
+
+ serialize: function(value)
+ {
+ var result = {};
+
+ var t = typeof(value);
+ //primitives are kept as such
+ if (t == "number" || t == "string" || t == "boolean" || t == null || t == undefined)
+ {
+ result = value;
+ }
+ else if (value instanceof Array)
+ {
+ //arrays are serializesd recursively
+ result = [];
+ for (var i = 0; i < value.length; i++)
+ {
+ result[i] = this.serialize(value[i]);
+ }
+ }
+ else if (t == "function")
+ {
+ //js functions are assigned an ID and stored in the local cache
+ result.type = FABridge.TYPE_JSFUNCTION;
+ result.value = this.getFunctionID(value);
+ }
+ else if (value instanceof ASProxy)
+ {
+ result.type = FABridge.TYPE_ASINSTANCE;
+ result.value = value.fb_instance_id;
+ }
+ else
+ {
+ result.type = FABridge.TYPE_ANONYMOUS;
+ result.value = value;
+ }
+
+ return result;
+ },
+
+ //on deserialization we always check the return for the specific error code that is used to marshall NPE's into JS errors
+ // the unpacking is done by returning the value on each pachet for objects/arrays
+ deserialize: function(packedValue)
+ {
+
+ var result;
+
+ var t = typeof(packedValue);
+ if (t == "number" || t == "string" || t == "boolean" || packedValue == null || packedValue == undefined)
+ {
+ result = this.handleError(packedValue);
+ }
+ else if (packedValue instanceof Array)
+ {
+ result = [];
+ for (var i = 0; i < packedValue.length; i++)
+ {
+ result[i] = this.deserialize(packedValue[i]);
+ }
+ }
+ else if (t == "object")
+ {
+ for(var i = 0; i < packedValue.newTypes.length; i++)
+ {
+ this.addTypeDataToCache(packedValue.newTypes[i]);
+ }
+ for (var aRefID in packedValue.newRefs)
+ {
+ this.createProxy(aRefID, packedValue.newRefs[aRefID]);
+ }
+ if (packedValue.type == FABridge.TYPE_PRIMITIVE)
+ {
+ result = packedValue.value;
+ }
+ else if (packedValue.type == FABridge.TYPE_ASFUNCTION)
+ {
+ result = this.getFunctionProxy(packedValue.value);
+ }
+ else if (packedValue.type == FABridge.TYPE_ASINSTANCE)
+ {
+ result = this.getProxy(packedValue.value);
+ }
+ else if (packedValue.type == FABridge.TYPE_ANONYMOUS)
+ {
+ result = packedValue.value;
+ }
+ }
+ return result;
+ },
+ //increases the reference count for the given object
+ addRef: function(obj)
+ {
+ this.target.incRef(obj.fb_instance_id);
+ },
+ //decrease the reference count for the given object and release it if needed
+ release:function(obj)
+ {
+ this.target.releaseRef(obj.fb_instance_id);
+ },
+
+ // check the given value for the components of the hard-coded error code : __FLASHERROR
+ // used to marshall NPE's into flash
+
+ handleError: function(value)
+ {
+ if (typeof(value)=="string" && value.indexOf("__FLASHERROR")==0)
+ {
+ var myErrorMessage = value.split("||");
+ if(FABridge.refCount > 0 )
+ {
+ FABridge.refCount--;
+ }
+ throw new Error(myErrorMessage[1]);
+ return value;
+ }
+ else
+ {
+ return value;
+ }
+ }
+};
+
+// The root ASProxy class that facades a flash object
+
+ASProxy = function(bridge, typeName)
+{
+ this.bridge = bridge;
+ this.typeName = typeName;
+ return this;
+};
+//methods available on each ASProxy object
+ASProxy.prototype =
+{
+ get: function(propName)
+ {
+ return this.bridge.deserialize(this.bridge.getPropertyFromAS(this.fb_instance_id, propName));
+ },
+
+ set: function(propName, value)
+ {
+ this.bridge.setPropertyInAS(this.fb_instance_id, propName, value);
+ },
+
+ call: function(funcName, args)
+ {
+ this.bridge.callASMethod(this.fb_instance_id, funcName, args);
+ },
+
+ addRef: function() {
+ this.bridge.addRef(this);
+ },
+
+ release: function() {
+ this.bridge.release(this);
+ }
+};
|