emInterface.js

// Frame aware Interface to Event Distribution code  (emInterface.js)

var residentFrameName;

var getLocalHandleEventFunctionObject = new Function("funcName",
	"var func = funcName; return func;");

function registerModule(module, functionName) {
	var handlerFuncName = functionName;

	if ( handlerFuncName == null )
		handlerFuncName = module + 'HandleEvent';
	if ( residentFrameName == null )
		discoverResidentFrameName();

	//only attempt to register module that is in resident frame
	var handlerFuncObject = getLocalHandleEventFunctionObject(handlerFuncName);
	try {
		eval(handlerFuncObject);
		handleEventFunctionObjects[module] = handlerFuncObject;
		
		//only register module that has local Handle Event function, in resident frame
		registerEventHandler(module, handlerFuncObject);
		logwr('info','registerModule() - Frame: '+ residentFrameName +';' +
				' Module: '+ module + ';');
	} catch (e) {
		logwr('info','registerModule() - Frame: '+ residentFrameName +';' +
				' Module: '+ module, e);
	}
}

function registerEventHandler(module, handlerFuncObject) {
	for (var i = 0; i < 5; i++) { 
		discoverEmRaiseEventFunction();
		if (emRaiseEventFunctionObject != null) break;
		
		var date = new Date();
		var curDate = null;
		do {
			curDate = new Date(); 
		} while(curDate-date < 100);
	}
	if ( emRaiseEventFunctionObject != null ) {
		//Event Mgr frame has been determined & Raise Event function established
		logwr('debug','registerEventHandler() - EM Frame: '+ emFrameName + ';' +
				' Module: '+ module + ';');
		var funcObj = null;;
		if (emFrameName == residentFrameName) {
			funcObj = emRegisterLocalEventHandler;	// local Event Hndlr registration function in emHandler.js
			if ( funcObj != null ) {
				funcObj.apply(null, [module, handlerFuncObject]);
				logwr('info','registerEventHandler() via local EM'  +
					' - Module: '+ module + ';');
			} else {
				logwr('warn','registerEventHandler() - null local funcObj;');
			}
		} else {
			// use remote Event Hndlr registration function in emHandler.js
			if (emFrameName == "" ) {
				funcObj = getWindowParent().emRegisterRemoteEventHandler;
				if ( funcObj != null ) {
					funcObj.apply(null, [module, residentFrameName]);
					logwr('info','registerEventHandler() via EM in parent'  +
						' - Module: '+ module + ';');
				} else {
					logwr('warn','registerEventHandler() - null parent funcObj;');
				}
			} else {
				var emFrame;
				if (getWindowParent() != window) {
					emFrame = getWindowParent().frames[emFrameName];
				} else {
					emFrame = window.frames[emFrameName];
				}
				if ( emFrame != null ) {
					funcObj = emFrame.emRegisterRemoteEventHandler;
					if ( funcObj != null ) {
						var errorMsg = funcObj.apply(null, [module, residentFrameName]);
						if (errorMsg.length > 0)
							logwr('warn',errorMsg);
						else
							logwr('info','registerEventHandler() via remote EM'  +
								' - Module: '+ module + ';');
					} else {
						logwr('warn','registerEventHandler() - null remote funcObj;');
					}
				} else {
					logwr('warn','registerEventHandler() - null emFrame;');
				}
			}
		}
	} else {
		logwr('error','registerEventHandler() - null emRaiseEventFunctionObject;');
	}
}

// discoverResidentFrameName()
// ..establish name of resident Frame
// ..if residing in parent window, set frame name == ""
function discoverResidentFrameName() {
	if ( residentFrameName == null ) {
		var frameName = window.name;
		var parentFrameName = getWindowParent().name;
		logwr('debug','discoverResidentFrameName() - parentFrameName = '+ parentFrameName + 
						'; frameName = '+ frameName +';');
		if ( frameName == null || parentFrameName == frameName ) {
			residentFrameName = "";
		} else {
			residentFrameName = frameName;
		}
	}
}

// -- Publish Event Interface Code -- //  

// Event Publishing function variable
// ..function object for use in calling emHandler.js's emRaiseEvent()
var emRaiseEventFunctionObject;

// raiseEvent()
// ..call Event Manager's emRaiseEvent() function
function raiseEvent(srcModule, event, parameters) {
	if ( residentFrameName == null )
		discoverResidentFrameName();
	if ( emRaiseEventFunctionObject == null ) {
		try {
			if ( handleEventFunctionObjects[srcModule] != null ) {
				//without knowing Event Mgr Frame, not registered  ..retry registration
				registerEventHandler(srcModule, handleEventFunctionObjects[srcModule]);
			} else {
				//src module may not require registration  ..retry emRaiseEvent() discovery
				discoverEmRaiseEventFunction();
			}
		} catch (e) {
		logwr('error','raiseEvent() - found emRaiseEventFunctionObject == null '+
					'..Exception when retrying discovery/registration for Event: '+ event +
					' from Module: ' + srcModule +';');
		}
	}
	if ( emRaiseEventFunctionObject != null )
		emRaiseEventFunctionObject.apply(null, [srcModule, event, parameters]);
	else
		logwr('warn','raiseEvent() - emRaiseEventFunctionObject == null;'+
					' Event: '+ event +';');
}

// discoverEmRaiseEventFunction()
// ..get object reference for Event Manager's emRaiseEvent() function
function discoverEmRaiseEventFunction() {
	if ( emRaiseEventFunctionObject == null ) {
		//look for Event Mgr in Parent window or another frame
		emRaiseEventFunctionObject = getWindowParent().emRaiseEvent;
		if ( emRaiseEventFunctionObject != null ) {
			emFrameName = "";	// found Event Mgr in parent window ..set frame name = ""
		} else {
			//not in Parent, search level 1 frames in alpha order
			var frameNameList = new Array();
			var frameList;
			if (getWindowParent() != window) {
				frameList = getWindowParent().frames;
			} else {
				frameList = window.frames;
			}
			var i;
			for (i = 0; i < frameList.length; i++) {
				frameNameList.push(frameList[i].name);
			}
			frameNameList.sort();	//insure ordered search (in case > 1 emHandler)
			logwr('debug','discoverEmRaiseEventFunction() - Frame count: '+ getWindowParent().frames.length +';');

			var frameName = '';
			var frameObject;
			for (i = 0; i < frameNameList.length; i++) {
				frameName = frameNameList[i];
				frameObject = frameList[i];
				if ( frameObject != null ) {
					emRaiseEventFunctionObject = frameObject.emRaiseEvent;
					if ( emRaiseEventFunctionObject != null ) {
						logwr('debug','discoverEmRaiseEventFunction() - Frame: '+ i +' / '+ frameName +';');
						emFrameName = frameName;	// found Event Mgr's frame ..set frame name
						break;
					} else {
						logwr('debug','discoverEmRaiseEventFunction() - non discovery Frame: '+ i +' / '+ frameName +';');
					}
				} else {
					logwr('warn','discoverEmRaiseEventFunction() - frameObject == null;');
				}
			}
		}
		if ( emRaiseEventFunctionObject == null ) {
			logwr('warn','discoverEmRaiseEventFunction() - emRaiseEventFunctionObject == null;');
		}
	}
}


// -- Handle Event Interface Code -- //  

// Remote Event Handling function list variable
// ..array list which maps Module ID to appropriate Event Handling function object
//   key   = ID of Module that resides in same frame as this interface code (e.g., ID = "xx")
//	 value = Module's Event Handling function object
var handleEventFunctionObjects = new Object();

// dynamic Event Handling function object determination variable
var getRemoteHandleEventFunctionObject = new Function("funcName", "frame",
	"var func = funcName; return func;");

// remoteHandleEvent()
// ..interface function for calling Handle Event function for remote Module
// ..remote Module == module not within in same frame as the Event Manager module
function remoteHandleEvent(event, parameters) {
	var destModule = parameters['destModule'];
	if ( destModule != null ) {
		var remoteHandleEventFunctionObject = handleEventFunctionObjects[destModule];
		if ( remoteHandleEventFunctionObject != null ) {
			try {
				eval(remoteHandleEventFunctionObject).apply(null, [event, parameters]);
			} catch (e) {
				logwr('error','remoteHandleEvent() - Exeption for '+
					' Event: '+ event, e);
			}
		} else {
			logwr('warn','remoteHandleEvent() - destModule == null;'+
					' Event: '+ event +';');
		}
	}
}