function SL4B_RttpProviderFactory()
{
}

SL4B_RttpProviderFactory.prototype.createRttpProvider = SL_T;


function SL_T(SL_Al)
{
	var SL_Jm = SL4B_Accessor.getConfiguration();
	var SL_Jn = null;
	if (SL_Jm.getRttpProvider() == SL4B_ScriptLoader.const_APPLET_RTTP_PROVIDER)
	{
		SL_Jn = new SL4B_AppletRttpProvider(SL_Al);
	}
	else if (SL_Jm.getRttpProvider() == SL4B_ScriptLoader.const_OBJECT_RTTP_PROVIDER)
	{
				alert("Object RTTP Provider support is not available in this version of SL4B");
	}
	else if (SL_Jm.getRttpProvider() == SL4B_ScriptLoader.const_JAVASCRIPT_RTTP_PROVIDER)
	{
		SL_Jn =  new SL4B_JavaScriptRttpProvider(SL_Al);
	}
	else if (SL_Jm.getRttpProvider() == SL4B_ScriptLoader.const_TEST_RTTP_PROVIDER)
	{
				SL_Jn = new SL4B_TestRttpProvider();
	}
	return SL_Jn;
}



SL4B_Accessor = new function() {
	
	this.SL_LN = null;

	
	this.SL_LO = null;

	
	this.SL_La = null;

	
	this.SL_LQ = null;

	
	this.SL_fw = null;

	
	this.SL_LS = null;

	
	this.SL_Ln = new SL4B_RttpProviderFactory();

	
	this.setExceptionHandler = function(SL_Am) {
		this.SL_LN = SL_Am;
	};

	
	this.getExceptionHandler = function() {
		return this.SL_LN;
	};


	
	this.getConfiguration = function() {
		return this.SL_LO;
	};

	
	this.setConfiguration = function(SL_Jm) {
		if(this.SL_LO != null)
		{
			throw new SL4B_Exception("The SL4B_Configuration has already been set and cannot be changed.")
		}
		else
		{
			this.SL_LO = SL_Jm;
		}
	};


	
	this.getBrowserAdapter = function() {
		if (this.SL_La == null)
		{
									throw new SL4B_Exception("BrowserAdapter has not been set");
		}
		return this.SL_La;
	};

	
	this.setBrowserAdapter = function(SL_Ap) {
		this.SL_La = SL_Ap;
	};


	
	this.getCredentialsProvider = function() {
		if (this.SL_LQ == null)
		{
									throw new SL4B_Exception("CredentialsProvider has not been set");
		}
		return this.SL_LQ;
	};

	
	this.setCredentialsProvider = function(SL_Aq) {
		this.SL_LQ = SL_Aq;
	};

	
	this.getRttpProvider = function() {
		if (this.SL_fw == null)
		{
									throw new SL4B_Exception("RttpProvider has not been set");
		}
		return this.SL_fw;
	};

	
	this.getUnderlyingRttpProvider = function() {
		if (this.SL_LS == null)
		{
									throw new SL4B_Exception("UnderlyingRttpProvider has not been set");
		}
		return this.SL_LS;
	};

	
	this.setRttpProvider = function(SL_Ar) {
		
		this.SL_fw = SL_Ar;
		SL_Ar.internalInitialise();
	};

	
	this.setUnderlyingRttpProvider = function(SL_Ar) {
		this.SL_LS = SL_Ar;

					};

	
	this.getLogger = function() {
		return SL4B_Logger;
	};

	
	this.getRttpProviderFactory = function() {
		return this.SL_Ln;
	};

	
	this.setRttpProviderFactory = function(SL_At) {
		this.SL_Ln = SL_At;
	};
};




SL4B_DebugLevel = new function()
{
	
	this.CRITICAL = "critical";
	
	
	this.ERROR = "error";
	
	
	this.NOTIFY = "notify";
	
	
	this.WARN = "warn";
	
	
	this.INFO = "info";
	
	
	this.DEBUG = "debug";
	
	
	this.RTTP_FINE = "rttp-fine";
	
	
	this.RTTP_FINER = "rttp-finer";
	
	
	this.RTTP_FINEST = "rttp-finest";
	
	
	this.const_CRITICAL_INT = 0;
	
	
	this.const_ERROR_INT = 1;
	
	
	this.const_NOTIFY_INT = 2;
	
	
	this.const_WARN_INT = 3;
	
	
	this.const_INFO_INT = 4;
	
	
	this.const_DEBUG_INT = 5;
	
	
	this.const_RTTP_FINE_INT = 6;
	
	
	this.const_RTTP_FINER_INT = 7;
	
	
	this.const_RTTP_FINEST_INT = 8;

	
	this.SL_Lp = new Object();
	
	
	this.SL_Lq = new Object();

	
	this.addDebugLevel = function(SL_Au, SL_Df) {
		this.SL_Lp[SL_Au] = SL_Df;
		this.SL_Lq[SL_Df] = SL_Au;
	};

	
	this.getNumericDebugLevel = function(SL_BC) {
		var SL_Jp;
		if (typeof SL_BC == "number")
		{
			SL_Jp = SL_BC;
		}
		else if (!isNaN(SL_BC))
		{
									SL_Jp = parseInt(SL_BC);
		}
		else if (typeof SL_BC != "string" || typeof this.SL_Lq[SL_BC.toLowerCase()] == "undefined")
		{
			throw new SL4B_Exception("Illegal debug level \"" + SL_BC + "\" specified");
		}
		else
		{
			SL_Jp = this.SL_Lq[SL_BC.toLowerCase()];
		}
		return SL_Jp;
	};

	
	this.getDebugLevelName = function(SL_BC) {
						var SL_Jq;
		if (typeof SL_BC == "string")
		{
			SL_Jq = SL_BC;
		}
		else if (typeof SL_BC == "number")
		{
			SL_Jq = this.SL_Lp[SL_BC];
		}
		return SL_Jq;
	};
	
		this.addDebugLevel(this.const_CRITICAL_INT, this.CRITICAL);
	this.addDebugLevel(this.const_ERROR_INT, this.ERROR);
	this.addDebugLevel(this.const_NOTIFY_INT, this.NOTIFY);
	this.addDebugLevel(this.const_WARN_INT, this.WARN);
	this.addDebugLevel(this.const_INFO_INT, this.INFO);
	this.addDebugLevel(this.const_DEBUG_INT, this.DEBUG);
	this.addDebugLevel(this.const_RTTP_FINE_INT, this.RTTP_FINE);
	this.addDebugLevel(this.const_RTTP_FINER_INT, this.RTTP_FINER);
	this.addDebugLevel(this.const_RTTP_FINEST_INT, this.RTTP_FINEST);
};



SL4B_Logger = new function()
{
	
	this.const_HTML = "html";
	
	
	this.const_ABOUT_BLANK = "about:blank";

	
	this.SL_Mr = null;

	
	this.SL_Mb = false;

	
	this.SL_MV = false;

	
	this.SL_Ma = false;

	
	this.SL_MQ = new Array();

	
	this.SL_MN = new Array();

	
	this.SL_MM = false;

	
	this.SL_Mp = -1;

	
	this.SL_La = null;

	
	this.SL_MG = new Array(/\{0\}/g, /\{1\}/g, /\{2\}/g, /\{3\}/g, /\{4\}/g, /\{5\}/g, /\{6\}/g, /\{7\}/g);

	
	this.replaceMessageParameters = function(SL_EE, SL_BA, SL_BB) {
		var SL_Jr = SL_BA.length;
		for (var SL_Js = SL_BB; SL_Js < SL_Jr; ++SL_Js)
		{
			SL_EE = SL_EE.replace(this.SL_MG[(SL_Js - SL_BB)], SL_BA[SL_Js]);
		}
		return SL_EE;
	};

	
	this.log = function(SL_BC, SL_EE) {
	   		if (typeof(SL_BC) == "number" && this.SL_Mp != -1)
		{
			if (this.SL_Mp >= SL_BC)
			{
				this.printMessage(SL4B_DebugLevel.getDebugLevelName(SL_BC) + ":   " + this.replaceMessageParameters(SL_EE, this.log.arguments, 2));
			}
		}
		else
		{	
			try
			{
				if (this.mustDebug(SL_BC))
				{
					this.printMessage(SL4B_DebugLevel.getDebugLevelName(SL_BC) + ":   " + this.replaceMessageParameters(SL_EE, this.log.arguments, 2));
				}
			}
			catch(e)
			{
				SL4B_Accessor.getExceptionHandler().processException(e);
			}
		}
	};

	
	this.alert = function(SL_EE) {
		var SL_Jt = this.replaceMessageParameters(SL_EE, this.alert.arguments, 1);

		this.printMessage(SL_Jt);

		try
		{
			if (this.mustDebug(SL4B_DebugLevel.NOTIFY))
			{
				this.synchronizedAlert(SL_Jt);
			}
		}
		catch(e)
		{
			SL4B_Accessor.getExceptionHandler().processException(e);
		}
	};

	
	this.synchronizedAlert = function(SL_EE) {
		this.SL_MN.push(SL_EE);
		if (!this.SL_MM)
		{
			this.SL_MM = true;
			while (this.SL_MN.length > 0)
			{
				alert(this.SL_MN.shift());
			}
			this.SL_MM = false;
		}
	};

	
	this.printMessage = function(SL_EE) {
				var SL_Jt = LF_DateStamp.createDateStamp() + " - " + this.replaceMessageParameters(SL_EE, this.printMessage.arguments, 1);
		this.SL_MQ.push(SL_Jt);

				if (this.SL_La == null)
		{
			this.SL_La= SL4B_Accessor.getBrowserAdapter();
		}
		if (this.SL_La != null)
		{
						this.SL_La.dump(SL_Jt + "\n");
		}

		try
		{
			if (this.SL_MV)
			{
								this.printMessagesToDebugConsole();
			}
		}
		catch(e)
		{
			SL4B_Accessor.getExceptionHandler().processException(e);
		}
	};

	
	this.printMessagesToDebugConsole = function() {
				while (this.SL_MQ.length > 0)
		{
			var SL_Jv = this.SL_MQ.shift();
			this.printMessageToDebugConsole(SL_Jv);
		}
	};

	
	this.printMessageToDebugConsole = function(SL_EE) {
		try
		{
			this.SL_Mr.SL_AJC(SL_EE);
		}
		catch(e)
		{
					}
	};
	
	
	this.useHtmlDebugWindow = function() {
		return (SL4B_Accessor.getConfiguration().getDebugWindowType() == this.const_HTML);
	};
	
	
	this.openDebugConsoleOnStartUp = function(SL_BI) {
		if ((SL_BI && this.useHtmlDebugWindow()) || (!SL_BI && !this.useHtmlDebugWindow()))
		{
			if (this.mustDebug(SL4B_DebugLevel.WARN))
			{
								this.openDebugConsole();
			}
		}
	};
	
	
	this.getDebugWindowName = function() {
		return "_sl4b_debug_" + SL4B_Accessor.getConfiguration().getFrameId();
	};

	
	this.openDebugConsole = function() {
		if (!this.SL_Mb && !this.SL_Ma)
		{
			this.SL_Mb = true;

			var SL_AJA = SL4B_Accessor.getConfiguration().getCommonDomain();
			var SL_Jx = this.getDebugWindowName();
			var SL_Jy = "height=400,width=600,status=no,toolbar=no,menubar=no,location=no,resizable=yes,scrollbars=yes";

			if (this.useHtmlDebugWindow())
			{
				var SL_KA = SL4B_ScriptLoader.getRootUrl() + "sl4b/logger/log-window.html?level=" + SL4B_Accessor.getConfiguration().getDebugLevel() + ((SL_AJA != null)?"&domain=" + SL_AJA:"");
				this.SL_Mr = window.open(SL_KA, SL_Jx, SL_Jy);
			}
			else
			{
				this.SL_Mr = window.open("", SL_Jx, SL_Jy);
	         
				var SL_KB = "<html><head><title>SL4B Debug Log [Debug level " + SL4B_Accessor.getConfiguration().getDebugLevel() + "]</title>";
				SL_KB += "<style type=\"text/css\"> body {font-family:Verdana;background-color:Black;color:#00ff00;} table {font-size:10px;}</style></head>";
				SL_KB += "<table width='100%'><tbody id=\"tblMessageLog\" cellpadding=\"0\" cellspacing=\"0\"></tbody></table>";
				SL_KB += "<scr" + "ipt type=\"text/javascript\" src=\"" + SL4B_ScriptLoader.getRootUrl() + "sl4b/logger/log-window.js\"></scr" + "ipt>";
				SL_KB += "</body></html>";

								try
				{
					var SL_KC = this.SL_Mr.document;
					SL_KC.open();
					SL_KC.write(SL_KB);
					SL_KC.close();
				}
				catch(e)
				{
										SL4B_Logger.alert("Your browser appears to have a popup blocker enabled which is preventing the SL4B debug console window from opening.\nPlease disable the popup blocker for this web site to view the console.");
				}
			}
		}
	};

	
	this.closeDebugConsole = function() {
		if (this.SL_Mr != null)
		{
			this.SL_Ma = true;

			this.SL_Mr.close();
		}
	};

	
	this.debugConsoleOpened = function() {
		this.SL_MV = true;

				this.printMessageToDebugConsole("Debug Console for frame \"" + SL4B_Accessor.getConfiguration().getFrameId() + "\"");

		this.printMessagesToDebugConsole();

		SL4B_Logger.log(SL4B_DebugLevel.const_RTTP_FINE_INT, "Logger.debugConsoleOpened: Adding logger as listener for close event.");

		try
		{
			SL4B_WindowEventHandler.addListener(this);
		}
		catch(e)
		{
						SL4B_Accessor.getExceptionHandler().processException(e);
		}
	};

	
	this.debugConsoleClosed = function() {
						this.SL_MV = false;

		this.SL_Mr = null;
	};

	
	this.mustDebug = function(SL_BJ) {
		return (this.getConfiguredDebugLevel() >= SL4B_DebugLevel.getNumericDebugLevel(SL_BJ));
	};

	
	this.getConfiguredDebugLevel = function() {
				if (this.SL_Mp == -1)
		{
						try
			{
				this.SL_Mp = SL4B_DebugLevel.getNumericDebugLevel(SL4B_Accessor.getConfiguration().getDebugLevel());
			}
			catch (e)
			{
								this.SL_Mp = SL4B_DebugLevel.getNumericDebugLevel(SL4B_DebugLevel.ERROR);
			}
		}
		return this.SL_Mp;
	};

	
	this.onUnload = function(SL_BK) {
				if (SL_BK != null && typeof SL_BK != "undefined" && !(SL_BK.ctrlKey && SL_BK.altKey))
		{
			try
			{
				this.SL_Mr.close();
			}
			catch(e)
			{
											}
		}
	};
};




LF_DateStamp = new function() {
	
	this.SL_Ms = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");

	
	this.SL_Mt = new Array("", "0", "00", "000");

	
		this.createDateStamp = function() {
		var SL_KD = new Date();
		var SL_KE = SL_KD.getTimezoneOffset();
		var SL_KF = Math.abs(SL_KE);
		var SL_KG = (SL_KE <= 0)?"+":"-";
		var SL_KH = this.padZeros(Math.floor(Math.abs(SL_KF) / 60), 2);
		var SL_KI = this.padZeros(SL_KF % 60, 2);
		return this.SL_Ms[SL_KD.getMonth()] + " " + this.padZeros(SL_KD.getDate(), 2) + " " + this.padZeros(SL_KD.getHours(), 2) + ":" + this.padZeros(SL_KD.getMinutes(), 2) + ":" + this.padZeros(SL_KD.getSeconds(), 2) + "." + this.padZeros(SL_KD.getMilliseconds(), 3) + " " + SL_KG + SL_KH + SL_KI;
	};

	
	this.padZeros = function(SL_BL, SL_BM) {
		var SL_KJ = (SL_BL + "").length;
		var SL_KK = SL_BM - SL_KJ;
		return this.SL_Mt[SL_KK] + SL_BL;
	};
};



function SL4B_AbstractBrowserAdapter()
{
}


SL4B_AbstractBrowserAdapter.isInternetExplorer = function() {
		return (navigator.userAgent.toLowerCase().match(/msie/) != null);
};


SL4B_AbstractBrowserAdapter.prototype.isFirefox = function() { throw new SL4B_Error("isFirefox method not implemented"); };


SL4B_AbstractBrowserAdapter.prototype.isInternetExplorer = function() { throw new SL4B_Error("isInternetExplorer method not implemented"); };



SL4B_AbstractBrowserAdapter.prototype.getBrowserVersion = function() { throw new SL4B_Error("getBrowserVersion method not implemented"); };



SL4B_AbstractBrowserAdapter.prototype.getElementById = function(SL_JT) { return document.getElementById(SL_JT); };


SL4B_AbstractBrowserAdapter.prototype.getFrameWindow = function(SL_Bf) { throw new SL4B_Error("getFrameWindow method not implemented"); };


SL4B_AbstractBrowserAdapter.prototype.addEventListener = function(SL_BU, SL_BV, SL_BW) { throw new SL4B_Error("addEventListener method not implemented"); };


SL4B_AbstractBrowserAdapter.prototype.dump = function(SL_EE) { };


SL4B_AbstractBrowserAdapter.prototype.convertExceptionToString = function(SL_BT) {
	var SL_ALa = null;
	if (typeof SL_BT.getClass != "undefined")
	{
				SL_ALa = SL_BT.getClass() + ": " + SL_BT.getMessage();
	}
	else if (typeof SL_BT.stack != "undefined")
	{
				SL_ALa = SL_BT.name + ": " + SL_BT.message + " (" + SL_BT.fileName + " [line " + SL_BT.lineNumber + "])";
	}
	else if (typeof SL_BT.description != "undefined")
	{
				SL_ALa = SL_BT.name + ": " + SL_BT.message;
	}
	else if (typeof SL_BT.toString != "undefined")
	{
		SL_ALa = SL_BT.toString();
	}
	else
	{
		SL_ALa = SL_BT + "";
	}
	return SL_ALa;
};





function SL4B_IEBrowserAdapter()
{
}

SL4B_IEBrowserAdapter.prototype = new SL4B_AbstractBrowserAdapter;


SL4B_IEBrowserAdapter.prototype.isFirefox = function() { return false; };


SL4B_IEBrowserAdapter.prototype.isInternetExplorer = function() { return true; };

SL4B_IEBrowserAdapter.prototype.getBrowserVersion = function() { 
		var SL_KM = window.navigator.userAgent;
	var SL_KN = SL_KM.indexOf("MSIE ");
	var SL_KO = SL_KM.substring(SL_KN+5,SL_KM.indexOf(";",SL_KN));
	return SL_KO.toLowerCase();
};

SL4B_IEBrowserAdapter.prototype.addEventListener = function(SL_BU, SL_BV, SL_BW) {
	SL_BU.attachEvent("on" + SL_BV, SL_BW);
};

SL4B_IEBrowserAdapter.prototype.getFrameWindow = function(SL_Bf) {
	var SL_KP = document.frames[SL_Bf];
	return ((typeof SL_KP == "undefined")?null:SL_KP);
};



if (SL4B_AbstractBrowserAdapter.isInternetExplorer())
{
		SL4B_Accessor.setBrowserAdapter(new SL4B_IEBrowserAdapter());
}



function SL4B_FirefoxBrowserAdapter()
{
}

SL4B_FirefoxBrowserAdapter.prototype = new SL4B_AbstractBrowserAdapter;


SL4B_FirefoxBrowserAdapter.prototype.isFirefox = function() { return true; };


SL4B_FirefoxBrowserAdapter.prototype.isInternetExplorer = function() { return false; };

SL4B_FirefoxBrowserAdapter.prototype.getBrowserVersion = function() { 
    return navigator.vendorSub;
};

SL4B_FirefoxBrowserAdapter.prototype.addEventListener = function(SL_BU, SL_BV, SL_BW) {
	SL_BU.addEventListener(SL_BV, SL_BW, false);
};

SL4B_FirefoxBrowserAdapter.prototype.dump = function(SL_EE) { dump(SL_EE); };

SL4B_FirefoxBrowserAdapter.prototype.getFrameWindow = function(SL_Bf) {
	var oIFrameElement = this.getElementById(SL_Bf);
	return ((oIFrameElement == null)?null:oIFrameElement.contentWindow);
};



if (!SL4B_AbstractBrowserAdapter.isInternetExplorer())
{
		SL4B_Accessor.setBrowserAdapter(new SL4B_FirefoxBrowserAdapter());
}



SL4B_FrameRegistrarAccessor = new function() {
	
	this.SL_NA = null;
	
	
	this.setCommonContainerDomain = function(SL_Bd) {
		SL4B_Accessor.getLogger().log(SL4B_DebugLevel.const_RTTP_FINEST_INT, "SL4B_FrameRegistrarAccessor.setCommonContainerDomain: domain \"{0}\"", SL_Bd);
		
				var SL_KR = SL4B_Accessor.getConfiguration().getContainerFrameLocation();
		var SL_KS = eval(SL_KR);
		
		if (window != SL_KS)
		{
						try
			{
				SL_KS.document.domain = SL_Bd;
				SL4B_Accessor.getLogger().log(SL4B_DebugLevel.const_INFO_INT, "SL4B_FrameRegistrarAccessor.setCommonContainerDomain: container frame domain set to \"{0}\"", SL_Bd);
			}
			catch (e)
			{
				SL4B_Accessor.getLogger().log(SL4B_DebugLevel.const_INFO_INT, "SL4B_FrameRegistrarAccessor.setCommonContainerDomain: failed to set container frame domain to \"{0}\"", SL_Bd);
			}
		}
		else
		{
			SL4B_Accessor.getLogger().log(SL4B_DebugLevel.const_INFO_INT, "SL4B_FrameRegistrarAccessor.setCommonContainerDomain: container frame domain was not set, this page is the container frame");
		}
	};

	
	this.getFrameRegistrar = function() {
		if (this.SL_NA == null)
		{
			var SL_KR = SL4B_Accessor.getConfiguration().getContainerFrameLocation();

						var SL_KS = eval(SL_KR);

									if (typeof SL_KS.SL4B_FrameRegistrar == "undefined")
			{
				SL_KS.SL4B_FrameRegistrar = new SL_X();
			}

						this.SL_NA = SL_KS.SL4B_FrameRegistrar;
		}

		return this.SL_NA;
	};

	
	this.setMasterFrame = function(SL_Be) {
        this.getFrameRegistrar().setMasterFrame(SL_Be);
	};

	
	this.removeMasterFrame = function() {
		SL4B_Logger.log(SL4B_DebugLevel.const_RTTP_FINEST_INT, "FrameRegistrarAccessor.removeMasterFrame");
		this.getFrameRegistrar().removeMasterFrame();
	};

	
	this.registerSlaveFrame = function(SL_Bf, SL_Bg) {
		this.getFrameRegistrar().registerSlaveFrame(SL_Bf, SL_Bg);
	};

	
	this.deregisterSlaveFrame = function(SL_Bf) {
		this.getFrameRegistrar().deregisterSlaveFrame(SL_Bf);
	};
};




function SL_X()
{
	
	this.SL_UD = null;

	
	this.SL_NN = new Object();

	
	this.setMasterFrame = function(SL_Be) {
		this.SL_UD = SL_Be;
		
		for(var SL_Bf in this.SL_NN)
		{
			var SL_KW = this.SL_NN[SL_Bf];
			SL_KW.masterRegistered(this.SL_UD);
		}
	};

	
	this.removeMasterFrame = function() {
		SL4B_Logger.log(SL4B_DebugLevel.const_RTTP_FINEST_INT, "FrameRegistrarAccessor.removeMasterFrame");
		this.SL_UD = null;

				for(var SL_Bf in this.SL_NN)
		{
			var SL_KW = this.SL_NN[SL_Bf];
			SL_KW.masterClosing();
		}
	};

	
	this.registerSlaveFrame = function(SL_Bf, SL_Bg) {
		this.SL_NN[SL_Bf] = SL_Bg;
		if(this.SL_UD != null)
		{
			SL_Bg.masterRegistered(this.SL_UD);
		}
	};

	
	this.deregisterSlaveFrame = function(SL_Bf) {
		delete(this.SL_NN[SL_Bf]);
	};
}




function SL4B_AbstractRttpProvider()
{
}


SL4B_AbstractRttpProvider.prototype.const_OK_CONNECTION_EVENT = "connectionOk";


SL4B_AbstractRttpProvider.prototype.const_RECONNECTION_OK_CONNECTION_EVENT = "reconnectionOk";


SL4B_AbstractRttpProvider.prototype.const_WARNING_CONNECTION_EVENT = "connectionWarning";


SL4B_AbstractRttpProvider.prototype.const_ERROR_CONNECTION_EVENT = "connectionError";


SL4B_AbstractRttpProvider.prototype.const_INFO_CONNECTION_EVENT = "connectionInfo";


SL4B_AbstractRttpProvider.prototype.const_FILE_DOWNLOAD_ERROR_CONNECTION_EVENT = "fileDownloadError";


SL4B_AbstractRttpProvider.prototype.const_LOGIN_ERROR_CONNECTION_EVENT = "loginError";


SL4B_AbstractRttpProvider.prototype.const_LOGIN_OK_CONNECTION_EVENT = "loginOk";


SL4B_AbstractRttpProvider.prototype.const_CREDENTIALS_RETRIEVED_CONNECTION_EVENT = "credentialsRetrieved";


SL4B_AbstractRttpProvider.prototype.const_MESSAGE_CONNECTION_EVENT = "message";


SL4B_AbstractRttpProvider.prototype.const_SOURCE_MESSAGE_CONNECTION_EVENT = "sourceMessage";


SL4B_AbstractRttpProvider.prototype.const_SERVICE_MESSAGE_CONNECTION_EVENT = "serviceMessage";


SL4B_AbstractRttpProvider.prototype.const_SESSION_EJECTED_CONNECTION_EVENT = "sessionEjected";


SL4B_AbstractRttpProvider.prototype.const_STATISTICS_CONNECTION_EVENT = "statistics";


SL4B_AbstractRttpProvider.const_OBJECT_NAME_DELIMITER  = " ";


SL4B_AbstractRttpProvider.prototype.SL_NO = new Array();


SL4B_AbstractRttpProvider.prototype.SL_NP = null;


SL4B_AbstractRttpProvider.prototype.SL_NQ = null;

SL4B_AbstractRttpProvider.prototype.getListener = SL_Z;

SL4B_AbstractRttpProvider.prototype.internalInitialise = SL_a;


SL4B_AbstractRttpProvider.prototype.initialise = function() { throw new SL4B_Error("initialise method not implemented"); };

SL4B_AbstractRttpProvider.prototype.internalStop = SL_b;
SL4B_AbstractRttpProvider.prototype.stop = SL_c;
SL4B_AbstractRttpProvider.prototype.register = SL_d; 
SL4B_AbstractRttpProvider.prototype.registerSlave = SL_e; 
SL4B_AbstractRttpProvider.prototype.deregisterSlave = SL_f;


SL4B_AbstractRttpProvider.prototype.connect = function() { throw new SL4B_Error("connect method not implemented"); };


SL4B_AbstractRttpProvider.prototype.reconnect = function() { throw new SL4B_Error("reconnect method not implemented"); };


SL4B_AbstractRttpProvider.prototype.connected = function() { 
	 try
	 { 
		 SL4B_Accessor.getCredentialsProvider().getCredentials(this); 
	 }
	 catch(e)
	 {
		 SL4B_Accessor.getExceptionHandler().processException(e); 
	 }
};


SL4B_AbstractRttpProvider.prototype.login = function(SL_ALx, SL_Bp) { throw new SL4B_Error("login method not implemented"); };

SL4B_AbstractRttpProvider.prototype.loggedIn = SL_g;
SL4B_AbstractRttpProvider.prototype.credentialsRetrieved = SL_h;


SL4B_AbstractRttpProvider.prototype.getObject = function(SL_DD, SL_AMa, SL_CC) { throw new SL4B_Error("getObject method not implemented"); };


SL4B_AbstractRttpProvider.prototype.getObjects = function(SL_DD, SL_DU, SL_CC) { throw new SL4B_Error("getObjects method not implemented"); };


SL4B_AbstractRttpProvider.prototype.removeObject = function(SL_DD, SL_AMa, SL_CC) { throw new SL4B_Error("removeObject method not implemented"); };


SL4B_AbstractRttpProvider.prototype.removeObjects = function(SL_DD, SL_DU, SL_CC) { throw new SL4B_Error("removeObjects method not implemented"); };


SL4B_AbstractRttpProvider.prototype.removeSubscriber = function(SL_DD) { throw new SL4B_Error("removeSubscriber method not implemented"); };


SL4B_AbstractRttpProvider.prototype.getFilteredObject = function(SL_DD, SL_AMa, SL_Cv, SL_Cw, SL_CC) {
	this.getObject(SL_DD, SL_AMa, this.createFieldListWithFilter(SL_Cv, SL_Cw, SL_CC));
};


SL4B_AbstractRttpProvider.prototype.getFilteredObjects = function(SL_DD, SL_DU, SL_Cv, SL_Cw, SL_CC) {
	this.getObjects(SL_DD, SL_DU, this.createFieldListWithFilter(SL_Cv, SL_Cw, SL_CC));
};


SL4B_AbstractRttpProvider.prototype.removeFilteredObject = function(SL_DD, SL_AMa, SL_Cv, SL_Cw, SL_CC) {
	this.removeObject(SL_DD, SL_AMa, this.createFieldListWithFilter(SL_Cv, SL_Cw, SL_CC));
};


SL4B_AbstractRttpProvider.prototype.removeFilteredObjects = function(SL_DD, SL_DU, SL_Cv, SL_Cw, SL_CC) {
	this.removeObjects(SL_DD, SL_DU, this.createFieldListWithFilter(SL_Cv, SL_Cw, SL_CC));
};


SL4B_AbstractRttpProvider.prototype.createFieldListWithFilter = function(SL_Cv, SL_Cw, SL_CC) {
	if (typeof SL_Cw == "undefined" || SL_Cw == null)
	{
				SL_Cw = true;
	}
	var SL_Ka = (SL_Cw?"filter=":"imagefilter=") + SL_Cv;
	if (SL_CC && SL_CC != "")
	{
		SL_Ka += "," + SL_CC;
	}
	return SL_Ka;
};


SL4B_AbstractRttpProvider.prototype.createFieldListForAutoDirectory = function(SL_Cv, SL_Cw, SL_CC) {
	var SL_Ka = "auto=1,monitor=1";
	 
	if (SL_Cv && SL_Cv != "")
	{
				SL_Ka += "," + this.createFieldListWithFilter(SL_Cv, SL_Cw, SL_CC);
	}
	else if (SL_CC && SL_CC != "")
	{
				SL_Ka += "," + SL_CC;
	}
	return SL_Ka;
};


SL4B_AbstractRttpProvider.prototype.getFilteredNewsHeadline = function(SL_DD, SL_AMa, SL_Cv) {
			this.getFilteredObject(SL_DD, SL_AMa, SL_Cv, true, SL_Cv);
};


SL4B_AbstractRttpProvider.prototype.getFilteredNewsHeadlines = function(SL_DD, SL_DU, SL_Cv) {
	this.getFilteredObjects(SL_DD, SL_DU, SL_Cv, true, SL_Cv);
};


SL4B_AbstractRttpProvider.prototype.removeFilteredNewsHeadline = function(SL_DD, SL_AMa, SL_Cv) {
	this.removeFilteredObject(SL_DD, SL_AMa, SL_Cv, true, SL_Cv);
};


SL4B_AbstractRttpProvider.prototype.removeFilteredNewsHeadlines = function(SL_DD, SL_DU, SL_Cv) {
	this.removeFilteredObjects(SL_DD, SL_DU, SL_Cv, true, SL_Cv);
};


SL4B_AbstractRttpProvider.prototype.getAutoDirectory = function(SL_DD, SL_Cy, SL_CC, SL_Cv, SL_Cw) { throw new SL4B_Error("getDirectory method not implemented"); };


SL4B_AbstractRttpProvider.prototype.removeAutoDirectory = function(SL_DD, SL_Cy, SL_CC, SL_Cv, SL_Cw) { throw new SL4B_Error("removeDirectory method not implemented"); };


SL4B_AbstractRttpProvider.prototype.getContainer = function(SL_DD, SL_JK, SL_CC) { throw new SL4B_Error("getContainer method not implemented"); };


SL4B_AbstractRttpProvider.prototype.removeContainer = function(SL_DD, SL_JK, SL_CC) { throw new SL4B_Error("removeContainer method not implemented"); };


SL4B_AbstractRttpProvider.prototype.getObjectType = function(SL_DD, SL_AMa) { throw new SL4B_Error("getObjectType method not implemented"); };


SL4B_AbstractRttpProvider.prototype.setThrottleObject = function(SL_AMa, SL_DM) { throw new SL4B_Error("setThrottleObject method not implemented"); };


SL4B_AbstractRttpProvider.prototype.setThrottleObjects = function(SL_DU, SL_DM) { throw new SL4B_Error("setThrottleObjects method not implemented"); };


SL4B_AbstractRttpProvider.prototype.setGlobalThrottle = function(SL_DM) { throw new SL4B_Error("setGlobalThrottle method not implemented"); };


SL4B_AbstractRttpProvider.prototype.disableWTStatsTimeout = function(SL_Dx) { throw new SL4B_Error("disableWTStatsTimeout method not implemented"); };


SL4B_AbstractRttpProvider.prototype.clearObjectListeners = function(SL_DD, SL_DS) { throw new SL4B_Error("clearObjectListeners method not implemented"); };


SL4B_AbstractRttpProvider.prototype.blockObjectListeners = function(SL_DD, SL_DU) { throw new SL4B_Error("blockObjectListeners method not implemented"); };


SL4B_AbstractRttpProvider.prototype.unblockObjectListeners = function(SL_DD, SL_DU) { throw new SL4B_Error("unblockObjectListeners method not implemented"); };


SL4B_AbstractRttpProvider.prototype.createObject = function(SL_AMa, SL_DY) { throw new SL4B_Error("createObject method not implemented"); };


SL4B_AbstractRttpProvider.prototype.contribObject = function(SL_DD, SL_AMa, SL_FX) { throw new SL4B_Error("contribObject method not implemented"); };


SL4B_AbstractRttpProvider.prototype.deleteObject = function(SL_AMa) { throw new SL4B_Error("deleteObject method not implemented"); };


SL4B_AbstractRttpProvider.prototype.getFieldNames = function() { throw new SL4B_Error("getFieldNames method not implemented"); };


SL4B_AbstractRttpProvider.prototype.logout = function() { throw new SL4B_Error("logout method not implemented"); };


SL4B_AbstractRttpProvider.prototype.debug = function(SL_Df, SL_EE) { throw new SL4B_Error("debug method not implemented"); };


SL4B_AbstractRttpProvider.prototype.setDebugLevel = function(SL_Df) { throw new SL4B_Error("setDebugLevel method not implemented"); };


SL4B_AbstractRttpProvider.prototype.getVersion = function() { throw new SL4B_Error("getVersion method not implemented"); };


SL4B_AbstractRttpProvider.prototype.getVersionInfo = function() { throw new SL4B_Error("getVersionInfo method not implemented"); };

SL4B_AbstractRttpProvider.prototype.addConnectionListener = SL_j;
SL4B_AbstractRttpProvider.prototype.removeConnectionListener = SL_k;
SL4B_AbstractRttpProvider.prototype.notifyConnectionListeners = SL_l;
SL4B_AbstractRttpProvider.prototype.onUnload = SL_m;


function SL_Z(SL_DD)
{
	var SL_Kb;
	if (SL_DD == null || typeof SL_DD == "undefined")
	{
		throw new SL4B_Exception("Subscriber cannot be null or undefined");
	}
	else if (typeof SL_DD == "object" && SL_DD.getIdentifier != 'undefined')
	{
		SL_Kb = SL_DD.getIdentifier();
	}
	else if (typeof SL_DD == "string")
	{
				SL_Kb = SL_DD;
	}
	else
	{
		throw new SL4B_Exception("Illegal Subscriber \"" + SL_DD + "\" defined");
	}
	return SL_Kb;
}


function SL_a()
{
		this.initialise();

	this.register();


	try
	{
				SL4B_WindowEventHandler.addListener(this);
	}
	catch(e)
	{
				SL4B_Accessor.getExceptionHandler().processException(e);
	}
	
		if (!SL4B_Accessor.getConfiguration().isNoBrowserStatus())
	{
		this.addConnectionListener(new SL_r());
	}
	
	
}


function SL_b()
{
	this.stop();

		if(this.SL_NQ != null)
	{
		this.SL_NQ();
	}
}


function SL_c()
{
	SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "AbstractRttpProvider.stop");

	this.logout();

		try
	{
		SL4B_FrameRegistrarAccessor.removeMasterFrame();
	}
	catch (e)
	{
					}

}

function SL_d()
{
	try
	{
      SL4B_FrameRegistrarAccessor.setMasterFrame(this);
	}
	catch (e)
	{
					}

	SL4B_SubscriptionManagerAccessor.addSubscriptionManager(SL4B_SubscriptionManager);
}


function SL_e(SL_Dh, SL_Bg, SL_Dk)
{
	SL4B_SubscriptionManagerAccessor.addSubscriptionManager(SL_Dk);
}


function SL_f(SL_Dh, SL_Bg, SL_Dk)
{
	SL4B_SubscriptionManagerAccessor.removeSubscriptionManager(SL_Dk);
}


function SL_g()
{
	C_CallbackQueue.addCallback(new Array(SL4B_Accessor.getRttpProvider(), "notifyConnectionListeners", this.const_LOGIN_OK_CONNECTION_EVENT));

			SL4B_SubscriptionManagerAccessor.ready();
}


function SL_h()
{
	C_CallbackQueue.addCallback(new Array(SL4B_Accessor.getRttpProvider(), "notifyConnectionListeners", this.const_CREDENTIALS_RETRIEVED_CONNECTION_EVENT, SL4B_Accessor.getCredentialsProvider().getUsername()));
}


function SL_j(SL_Dp)
{
	this.SL_NO.push(SL_Dp);
}


function SL_k(SL_Dp)
{
	var SL_Kc = -1;
		for (var SL_Kd = 0, SL_AJl = this.SL_NO.length; SL_Kd < SL_AJl; ++SL_Kd)
	{
		if (this.SL_NO[SL_Kd] == SL_Dp)
		{
			SL_Kc = SL_Kd;
			break;
		}
	}

	if (SL_Kc != -1)
	{
		this.SL_NO.splice(SL_Kc, 1);
	}

	return (SL_Kc != -1);
}


function SL_l(SL_BV)
{
	var SL_Ke = SL_l.arguments;
			var SL_Kf = "Connection Event \"" + SL_BV + "\" ( ";
	for (var SL_Kg = 1, SL_AJl = SL_Ke.length; SL_Kg < SL_AJl; ++SL_Kg)
	{
		SL_Kf += ((typeof SL_Ke[SL_Kg] == "string")?"\"" + SL_Ke[SL_Kg] + "\"":SL_Ke[SL_Kg]) + ((SL_Kg + 1 != SL_AJl)?", ":" ");
	}
	SL_Kf += ")";

		var SL_Kh = (SL_BV == this.const_SOURCE_MESSAGE_CONNECTION_EVENT || SL_BV == this.const_SERVICE_MESSAGE_CONNECTION_EVENT || SL_BV == this.const_MESSAGE_CONNECTION_EVENT || SL_BV == this.const_STATISTICS_CONNECTION_EVENT);
	SL4B_Logger.log((SL_Kh?SL4B_DebugLevel.const_INFO_INT:SL4B_DebugLevel.const_NOTIFY_INT), SL_Kf);

		var SL_Kj = new Array();
	for (var SL_Kd = 0, SL_AJl = this.SL_NO.length; SL_Kd < SL_AJl; ++SL_Kd)
	{
		SL_Kj.push(this.SL_NO[SL_Kd]);
	}

	for (var SL_Kd = 0, SL_AJl = SL_Kj.length; SL_Kd < SL_AJl; ++SL_Kd)
	{
		try
		{
			switch(SL_BV)
			{
			case this.const_ERROR_CONNECTION_EVENT:
				SL_Kj[SL_Kd].connectionError();
				break;
			case this.const_WARNING_CONNECTION_EVENT:
				SL_Kj[SL_Kd].connectionWarning(SL_Ke[1]);
				break;
			case this.const_INFO_CONNECTION_EVENT:
				SL_Kj[SL_Kd].connectionInfo(SL_Ke[1]);
				break;
			case this.const_OK_CONNECTION_EVENT:
				SL_Kj[SL_Kd].connectionOk(SL_Ke[1], SL_Ke[2], SL_Ke[3]);
				break;
			case this.const_RECONNECTION_OK_CONNECTION_EVENT:
				SL_Kj[SL_Kd].reconnectionOk();
				break;
			case this.const_FILE_DOWNLOAD_ERROR_CONNECTION_EVENT:
				SL_Kj[SL_Kd].fileDownloadError(SL_Ke[1], SL_Ke[2]);
				break;
			case this.const_LOGIN_ERROR_CONNECTION_EVENT:
				SL_Kj[SL_Kd].loginError(SL_Ke[1]);
				break;
			case this.const_LOGIN_OK_CONNECTION_EVENT:
				SL_Kj[SL_Kd].loginOk();
				break;
			case this.const_CREDENTIALS_RETRIEVED_CONNECTION_EVENT:
				SL_Kj[SL_Kd].credentialsRetrieved(SL_Ke[1]);
				break;
			case this.const_MESSAGE_CONNECTION_EVENT:
				SL_Kj[SL_Kd].message(SL_Ke[1], SL_Ke[2]);
				break;
			case this.const_SERVICE_MESSAGE_CONNECTION_EVENT:
				SL_Kj[SL_Kd].serviceMessage(SL_Ke[1], SL_Ke[2], SL_Ke[3], SL_Ke[4]);
				break;
			case this.const_SESSION_EJECTED_CONNECTION_EVENT:
				SL_Kj[SL_Kd].sessionEjected(SL_Ke[1], SL_Ke[2]);
				break;
			case this.const_SOURCE_MESSAGE_CONNECTION_EVENT:
				SL_Kj[SL_Kd].sourceMessage(SL_Ke[1], SL_Ke[2], SL_Ke[3], SL_Ke[4]);
				break;
			case this.const_STATISTICS_CONNECTION_EVENT:
				SL_Kj[SL_Kd].statistics(SL_Ke[1], SL_Ke[2], SL_Ke[3], SL_Ke[4], SL_Ke[5]);
				break;
			default:
								SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "AbstractRttpProvider.notifyConnectionListeners: "+
								"Received an unknown connection event '"+SL_BV+"'. Ignoring event.");
			}
		}
		catch (e)
		{
			SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "AbstractRttpProvider.notifyConnectionListeners: Exception thrown by a listener whilst processing a \"{0}\" event; exception was {1}", SL_BV, SL4B_Accessor.getBrowserAdapter().convertExceptionToString(e));
		}
	}
}


function SL_m(SL_BK)
{
		SL4B_Accessor.getRttpProvider().internalStop();
}




function SL4B_ConnectionListener()
{
}


SL4B_ConnectionListener.prototype.connectionWarning = function(SL_EE) { };


SL4B_ConnectionListener.prototype.connectionInfo = function(SL_EE) { };


SL4B_ConnectionListener.prototype.connectionOk = function(SL_Eg, SL_Dw, SL_Dx) { };


SL4B_ConnectionListener.prototype.reconnectionOk = function() { };


SL4B_ConnectionListener.prototype.fileDownloadError = function(SL_Dy, SL_El) { };


SL4B_ConnectionListener.prototype.loginError = function(SL_EE) { };


SL4B_ConnectionListener.prototype.loginOk = function() { };


SL4B_ConnectionListener.prototype.credentialsRetrieved = function(SL_ALx) { };


SL4B_ConnectionListener.prototype.message = function(SL_EF, SL_EE) { };


SL4B_ConnectionListener.prototype.connectionError = function() { };


SL4B_ConnectionListener.prototype.serviceMessage = function(SL_EF, SL_EG, SL_EH, SL_EE) { };


SL4B_ConnectionListener.prototype.sessionEjected = function(SL_EF, SL_EE) { };


SL4B_ConnectionListener.prototype.sourceMessage = function(SL_EF, SL_Ex, SL_Ey, SL_EE) { };


SL4B_ConnectionListener.prototype.statistics = function(SL_EP, SL_EQ, SL_Dx, SL_ES, SL_FF) { };




SL4B_ThrottleLevel = new function() {
	
	this.MINIMUM = "min";
	
	
	this.DOWN = "down";
	
	
	this.UP = "up";
	
	
	this.MAXIMUM = "max";
	
	
	this.STOP = "stop";
	
	
	this.START = "start";
	
	
	this.DEFAULT = "def";
};




SL4B_ObjectType = new function() {
	
	this.DIRECTORY = "220";

	
	this.PAGE = "221";

	
	this.RECORD = "222";

	
	this.NEWS_HEADLINE = "223";

	
	this.NEWS_STORY = "224";

	
	this.CHAT = "227";

	
	this.CONTAINER = "228";

	
	this.AUTO_DIRECTORY = "229";

	
	this.SL_Na = new Object();
	this.SL_Na[this.DIRECTORY] = "directory";
	this.SL_Na[this.PAGE] = "page";
	this.SL_Na[this.RECORD] = "record";
	this.SL_Na[this.NEWS_HEADLINE] = "news headline";
	this.SL_Na[this.NEWS_STORY] = "news story";
	this.SL_Na[this.CHAT] = "chat";
	this.SL_Na[this.CONTAINER] = "container";
	this.SL_Na[this.AUTO_DIRECTORY] = "auto directory";

	
	this.getName = function(SL_EU) {
		var SL_Km = this.SL_Na[SL_EU];
		return ((typeof SL_Km == "undefined")?null:SL_Km);
	};
};




SL4B_FileType = new function() {
	
	this.URL_CHECK = "URL check";

	
	this.APPLET_CHECK = "Applet check";

	
	this.RTTP_APPLET = "RTTP applet";
};




function SL4B_ContributionFieldData()
{
	
	this.SL_Np = new Array();
}


SL4B_ContributionFieldData.prototype.addField = function(SL_Ik, SL_EW) { this.SL_Np.push(new SL_q(SL_Ik, SL_EW)); };


SL4B_ContributionFieldData.prototype.size = function() { return this.SL_Np.length; };


SL4B_ContributionFieldData.prototype.getField = function(SL_EX) {
	if (SL_EX >= this.SL_Np.length || SL_EX < 0)
	{
		throw new SL4B_Exception("getField: specified field index \"" + SL_EX + "\" is out of bounds");
	}
	return this.SL_Np[SL_EX];
};


SL4B_ContributionFieldData.prototype.toString = function() { return this.SL_Np.join(" "); };




function SL_q(SL_Km, SL_ALa)
{
	
	
	this.SL_ve = SL_Km;

	
	this.SL_AFI = SL_ALa;
}


SL_q.prototype.toString = function() { return "[" + this.SL_ve + "=" + this.SL_AFI + "]"; };




function SL_r()
{
	this.showStatus = function(SL_EE)
	{
		window.status = SL_EE;
	};
}

SL_r.prototype = new SL4B_ConnectionListener;

SL_r.prototype.connectionWarning = function(SL_EE) {this.showStatus("Connection Warning: " + SL_EE ); };
SL_r.prototype.connectionInfo = function(SL_EE) {this.showStatus("Connection Information: " + SL_EE ); };
SL_r.prototype.connectionOk = function(SL_Eg, SL_Dw, SL_Dx){this.showStatus("Connection OK: " + SL_Eg +", " + SL_Dw + ", " + SL_Dx); };
SL_r.prototype.reconnectionOk = function(SL_Eg, SL_Dw, SL_Dx){this.showStatus("Reconnection OK"); };
SL_r.prototype.fileDownloadError = function(SL_Dy, SL_El) {this.showStatus("File Download Error: " +SL_Dy + ", " + SL_El ); };
SL_r.prototype.loginError = function(SL_EE) {this.showStatus("Login Error: " + SL_EE);  };
SL_r.prototype.loginOk = function() {this.showStatus("Login Ok"); };
SL_r.prototype.message = function(SL_EF, SL_EE) {this.showStatus("Message :" + SL_EF + ", " + SL_EE ); };
SL_r.prototype.connectionError = function() { this.showStatus("Connection Error: connection lost"); };
SL_r.prototype.serviceMessage = function(SL_EF, SL_EG, SL_EH, SL_EE) {};SL_r.prototype.sessionEjected = function(SL_EF, SL_EE) {this.showStatus("Session Ejected: "+SL_EF + ", "  + SL_EE ); };
SL_r.prototype.sourceMessage = function(SL_EF, SL_Ex, SL_Ey, SL_EE) {};SL_r.prototype.statistics = function(SL_EP, SL_EQ, SL_Dx, SL_ES, SL_FF) {};



function SL4B_AbstractSubscriber()
{
}


SL4B_AbstractSubscriber.prototype.SL_OA = null;


SL4B_AbstractSubscriber.prototype.SL_OB = null;


SL4B_AbstractSubscriber.prototype.initialise = SL_t;


SL4B_AbstractSubscriber.prototype.getIdentifier = function() { return SL4B_SubscriptionManager.getListenerPrefix() + this.SL_OA; };


SL4B_AbstractSubscriber.prototype.getLocalIdentifier = function() { return SL4B_SubscriptionManager.getLocalListenerPrefix() + this.SL_OA; };


SL4B_AbstractSubscriber.prototype.ready = function() { SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "AbstractSubscriber.ready invoked but not overridden"); };





SL4B_AbstractSubscriber.prototype.WTChat = SL_u;
SL4B_AbstractSubscriber.prototype.WTContribOk = SL_v;
SL4B_AbstractSubscriber.prototype.WTContribFailed = SL_w;
SL4B_AbstractSubscriber.prototype.WTDirUpdated = SL_x;
SL4B_AbstractSubscriber.prototype.WTFieldDeleted = SL_y;
SL4B_AbstractSubscriber.prototype.WTType2Clear = SL_AA;
SL4B_AbstractSubscriber.prototype.WTType3Clear = SL_AB;
SL4B_AbstractSubscriber.prototype.WTNewsUpdated = SL_AC;
SL4B_AbstractSubscriber.prototype.WTObjectDeleted = SL_AD;
SL4B_AbstractSubscriber.prototype.WTObjectInfo = SL_AE;
SL4B_AbstractSubscriber.prototype.WTObjectNotFound = SL_AF;
SL4B_AbstractSubscriber.prototype.WTObjectNotStale = SL_AG;
SL4B_AbstractSubscriber.prototype.WTObjectReadDenied = SL_AH;
SL4B_AbstractSubscriber.prototype.WTObjectStale = SL_AI;
SL4B_AbstractSubscriber.prototype.WTObjectStatus = SL_AJ;
SL4B_AbstractSubscriber.prototype.WTObjectType = SL_AK;
SL4B_AbstractSubscriber.prototype.WTObjectUnavailable = SL_AL;
SL4B_AbstractSubscriber.prototype.WTObjectUpdated = SL_AM;
SL4B_AbstractSubscriber.prototype.WTObjectWriteDenied = SL_AN;
SL4B_AbstractSubscriber.prototype.WTPageUpdated = SL_AO;
SL4B_AbstractSubscriber.prototype.WTRecordMultiUpdated = SL_AP;
SL4B_AbstractSubscriber.prototype.WTRecordUpdated = SL_AQ;
SL4B_AbstractSubscriber.prototype.WTStoryReset = SL_AR;
SL4B_AbstractSubscriber.prototype.WTStoryUpdated = SL_AS;
SL4B_AbstractSubscriber.prototype.WTStructureChange = SL_AT;
SL4B_AbstractSubscriber.prototype.WTPermissionUpdated = SL_AU;
SL4B_AbstractSubscriber.prototype.WTPermissionDeleted = SL_AV;
SL4B_AbstractSubscriber.prototype.dequeueNextMultiUpdate = SL_AW;





SL4B_AbstractSubscriber.prototype.structureChange = function(SL_JK, SL_AMa, SL_JM, SL_Gk) { this.methodNotImplemented("structureChange"); };



SL4B_AbstractSubscriber.prototype.chat = function(SL_AMa, SL_GZ, SL_ALx, SL_EE, SL_AMA) { this.methodNotImplemented("chat"); };


SL4B_AbstractSubscriber.prototype.contribOk = function(SL_AMa) { this.methodNotImplemented("contribOk"); };


SL4B_AbstractSubscriber.prototype.contribFailed = function(SL_AMa, SL_AMb) { this.methodNotImplemented("contribFailed"); };


SL4B_AbstractSubscriber.prototype.directoryUpdated = function(SL_FW, SL_AMa, SL_HI, SL_Gk) { this.methodNotImplemented("directoryUpdated"); };


SL4B_AbstractSubscriber.prototype.directoryMultiUpdated = function(SL_FW, SL_FX) { this.methodNotImplemented("recordMultiUpdated"); };


SL4B_AbstractSubscriber.prototype.fieldDeleted = function(SL_AMa, SL_Ik, SL_AMT) { this.methodNotImplemented("fieldDeleted"); };


SL4B_AbstractSubscriber.prototype.type2Clear = function(SL_AMa) { this.methodNotImplemented("type2Clear"); };


SL4B_AbstractSubscriber.prototype.type3Clear = function(SL_AMa) { this.methodNotImplemented("type3Clear"); };


SL4B_AbstractSubscriber.prototype.newsUpdated = function(SL_AMa, SL_ALs, SL_ALk, SL_ALl) { this.methodNotImplemented("newsUpdated"); };


SL4B_AbstractSubscriber.prototype.objectDeleted = function(SL_AMa) { this.methodNotImplemented("objectDeleted"); };


SL4B_AbstractSubscriber.prototype.objectInfo = function(SL_AMa, SL_HI, SL_Fl, SL_ALa) { this.methodNotImplemented("objectInfo"); };


SL4B_AbstractSubscriber.prototype.objectNotFound = function(SL_AMa) { this.methodNotImplemented("objectNotFound"); };


SL4B_AbstractSubscriber.prototype.objectNotStale = function(SL_AMa, SL_Ik) { this.methodNotImplemented("objectNotStale"); };


SL4B_AbstractSubscriber.prototype.objectReadDenied = function(SL_AMa) { this.methodNotImplemented("objectReadDenied"); };


SL4B_AbstractSubscriber.prototype.objectStale = function(SL_AMa, SL_Ik) { this.methodNotImplemented("objectStale"); };


SL4B_AbstractSubscriber.prototype.objectStatus = function(SL_AMa, SL_HI, SL_HJ, SL_EE) { this.methodNotImplemented("objectStatus"); };


SL4B_AbstractSubscriber.prototype.objectType = function(SL_AMa, SL_AMD, SL_AME) { this.methodNotImplemented("objectType"); };


SL4B_AbstractSubscriber.prototype.objectUnavailable = function(SL_AMa) { this.methodNotImplemented("objectUnavailable"); };


SL4B_AbstractSubscriber.prototype.objectUpdated = function(SL_AMa) { this.methodNotImplemented("objectUpdated"); };


SL4B_AbstractSubscriber.prototype.objectWriteDenied = function(SL_AMa) { this.methodNotImplemented("objectWriteDenied"); };


SL4B_AbstractSubscriber.prototype.pageUpdated = function(SL_AMa, SL_GG, SL_GH, SL_GI, SL_GJ) { this.methodNotImplemented("pageUpdated"); };


SL4B_AbstractSubscriber.prototype.recordMultiUpdated = function(SL_AMa, SL_FX) {
		for (var SL_Kn=0, l_nSize = SL_FX.size(); SL_Kn < l_nSize; SL_Kn++)
	{
		try
		{
			this.recordUpdated(SL_AMa, SL_FX.getFieldName(SL_Kn), SL_FX.getFieldValue(SL_Kn));
		}
		catch (e)
		{
			SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "AbstractSubscriber.recordMultiUpdated: Exception thrown by subscriber whilst invoking its recordUpdated method; exception was {0}", SL4B_Accessor.getBrowserAdapter().convertExceptionToString(e));
		}
	}
};


SL4B_AbstractSubscriber.prototype.recordUpdated = function(SL_AMa, SL_Ik, SL_ALa) { this.methodNotImplemented("recordUpdated"); };


SL4B_AbstractSubscriber.prototype.storyReset = function(SL_AMa) { this.methodNotImplemented("storyReset"); };


SL4B_AbstractSubscriber.prototype.storyUpdated = function(SL_AMa, SL_JJ) { this.methodNotImplemented("storyUpdated"); };


SL4B_AbstractSubscriber.prototype.permissionUpdated = function(SL_AMa, SL_Hk, SL_FX) { this.methodNotImplemented("permissionUpdated"); };


SL4B_AbstractSubscriber.prototype.permissionDeleted = function(SL_AMa, SL_Hk) { this.methodNotImplemented("permissionDeleted"); };


SL4B_AbstractSubscriber.prototype.methodNotImplemented = function(SL_GX) { SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "AbstractSubscriber.{0} invoked but not overridden", SL_GX); };


function SL_t()
{
	this.SL_OA = SL4B_SubscriptionManager.addSubscriber(this);

	this.SL_OB = new Array();

			if (SL4B_SubscriptionManager.isReady())
	{
		C_CallbackQueue.addCallback(new Array(this, "ready"));
	}
}


function SL_u(SL_AMa, SL_GZ, SL_ALx, SL_EE, SL_AMA)
{
	C_CallbackQueue.addCallback(new Array(this + "chat", SL_AMa, SL_GZ, SL_ALx, SL_EE, SL_AMA));
}


function SL_v(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "contribOk", SL_AMa));
}


function SL_w(SL_AMa, SL_AMb)
{
	C_CallbackQueue.addCallback(new Array(this, "contribFailed", SL_AMa, SL_AMb));
}


function SL_x(SL_FW, SL_AMa, SL_HI, SL_Gk)
{
	C_CallbackQueue.addCallback(new Array(this, "directoryUpdated", SL_FW, SL_AMa, SL_HI, SL_Gk));
}


function SL_y(SL_AMa, SL_Ik, SL_AMT)
{
	C_CallbackQueue.addCallback(new Array(this, "fieldDeleted", SL_AMa, SL_Ik, SL_AMT));
}


function SL_AA(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "type2Clear", SL_AMa));
}


function SL_AB(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "type3Clear", SL_AMa));
}


function SL_AC(SL_AMa, SL_ALs, SL_ALk, SL_ALl)
{
	C_CallbackQueue.addCallback(new Array(this, "newsUpdated", SL_AMa, SL_ALs, SL_ALk, SL_ALl));
}


function SL_AD(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "objectDeleted", SL_AMa));
}


function SL_AE(SL_AMa, SL_HI, SL_Fl, SL_ALa)
{
	C_CallbackQueue.addCallback(new Array(this, "objectInfo", SL_AMa, SL_HI, SL_Fl, SL_ALa));
}


function SL_AF(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "objectNotFound", SL_AMa));
}


function SL_AG(SL_AMa, SL_Ik)
{
	C_CallbackQueue.addCallback(new Array(this, "objectNotStale", SL_AMa, SL_Ik));
}


function SL_AH(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "objectReadDenied", SL_AMa));
}


function SL_AI(SL_AMa, SL_Ik)
{
	C_CallbackQueue.addCallback(new Array(this, "objectStale", SL_AMa, SL_Ik));
}


function SL_AJ(SL_AMa, SL_HI, SL_HJ, SL_EE)
{
	C_CallbackQueue.addCallback(new Array(this, "objectStatus", SL_AMa, SL_HI, SL_HJ, SL_EE));
}


function SL_AK(SL_AMa, SL_AMD, SL_AME)
{
	C_CallbackQueue.addCallback(new Array(this, "objectType", SL_AMa, SL_AMD, SL_AME));
}


function SL_AL(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "objectUnavailable", SL_AMa));
}


function SL_AM(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "objectUpdated", SL_AMa));
}


function SL_AN(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "objectWriteDenied", SL_AMa));
}


function SL_AO(SL_AMa, SL_GG, SL_GH, SL_GI, SL_GJ)
{
	C_CallbackQueue.addCallback(new Array(this, "pageUpdated", SL_AMa, SL_GG, SL_GH, SL_GI, SL_GJ));
}


function SL_AP(SL_AMa, SL_FX)
{
		this.SL_OB.push(new SL_AX(SL_AMa, SL_FX, SL_AX.const_RECORD_UPDATE_TYPE, null));

		C_CallbackQueue.addCallback(new Array(this, "dequeueNextMultiUpdate"));
}


function SL_AQ(SL_AMa, SL_Ik, SL_ALa)
{
	C_CallbackQueue.addCallback(new Array(this, "recordUpdated", SL_AMa, SL_Ik, SL_ALa));
}


function SL_AR(SL_AMa)
{
	C_CallbackQueue.addCallback(new Array(this, "storyReset", SL_AMa));
}


function SL_AS(SL_AMa, SL_JJ)
{
	C_CallbackQueue.addCallback(new Array(this, "storyUpdated", SL_AMa, SL_JJ));
}


function SL_AT(SL_JK, SL_AMa, SL_JM, SL_Gk)
{
	C_CallbackQueue.addCallback(new Array(this, "structureChange", SL_JK, SL_AMa, SL_JM, SL_Gk));
}


function SL_AU(SL_AMa, SL_Hk, SL_FX)
{
	this.SL_OB.push(new SL_AX(SL_AMa, SL_FX, SL_AX.const_PERMISSION_UPDATE_TYPE, new Array(SL_Hk)));

		C_CallbackQueue.addCallback(new Array(this, "dequeueNextMultiUpdate"));
}


function SL_AV(SL_AMa, SL_Hk)
{
	C_CallbackQueue.addCallback(new Array(this, "permissionDeleted", SL_AMa, ((!SL_Hk)?null:SL_Hk)));
}


function SL_AW()
{
		var SL_Kp = this.SL_OB.shift();
	if (SL_Kp != null)
	{
		if (SL_Kp.SL_WF == SL_AX.const_RECORD_UPDATE_TYPE)
		{
         this.recordMultiUpdated(SL_Kp.SL_xg, SL_Kp.SL_OO);
		}
		else if (SL_Kp.SL_WF == SL_AX.const_PERMISSION_UPDATE_TYPE)
		{
			this.permissionUpdated(SL_Kp.SL_xg, SL_Kp.SL_OQ[0], SL_Kp.SL_OO);
		}
		else
		{
			SL4B_Logger.log(SL4B_DebugLevel.const_INFO_INT, "AbstractSubscriber.dequeueNextMultiUpdate: unknown update type: {0}.", SL_Kp.SL_WF);
		}
	}
	else
	{
		SL4B_Logger.log(SL4B_DebugLevel.const_INFO_INT, "AbstractSubscriber.dequeueNextMultiUpdate: method invoked with no more multi updates left in the queue.");
	}
}




function SL_AX(SL_AMa, SL_FX, SL_HI, SL_Hs)
{
	
	this.SL_xg = SL_AMa;

	
	this.SL_OO = SL_FX;

	
	this.SL_WF = SL_HI;

	
	this.SL_OQ = SL_Hs;
}


SL_AX.const_RECORD_UPDATE_TYPE = 1;


SL_AX.const_PERMISSION_UPDATE_TYPE = 2;




function SL4B_RecordFieldData()
{
	
	this.SL_OR = new Array();
	this.SL_Ob = new Array();
	this.SL_Oc = new SL_q();
}


SL4B_RecordFieldData.prototype.size = function() 
{ 
	return this.SL_OR.length;
};


SL4B_RecordFieldData.prototype.getField = function(SL_EX) 
{ 
	if (typeof this.SL_OR[SL_EX] == "undefined") 
	{
		return null;
	}
	
	this.SL_Oc.SL_ve = this.SL_OR[SL_EX];
	this.SL_Oc.SL_AFI = this.SL_Ob[SL_EX];
	return this.SL_Oc;
};


SL4B_RecordFieldData.prototype.getFieldName = function(SL_EX) 
{ 
	if (typeof this.SL_OR[SL_EX] == "undefined") 
	{
		return null;
	}
	return this.SL_OR[SL_EX];
};


SL4B_RecordFieldData.prototype.getFieldValue = function(SL_EX) 
{ 
	if (typeof this.SL_Ob[SL_EX] == "undefined") 
	{
		return null;
	}
	return this.SL_Ob[SL_EX];
}
;


SL4B_RecordFieldData.prototype.add = function(SL_Ik, SL_EW) 
{ 
	this.SL_OR.push(SL_Ik); 
	this.SL_Ob.push(SL_EW);
};



SL4B_SubscriptionManager = new function()
{
	
	this.SL_PA = 0;

	
	this.SL_PP = false;

	
	this.SL_Oq = new Array();

	
	this.SL_Ot = null;

	
	this.SL_Ow = null;

	
	this.getSubscribers = function() {
		return this.SL_Oq;
	};

	
	this.getSubscriber = function(SL_Kq) {
		return this.SL_Oq[SL_Kq];
	};

	
	this.addSubscriber = function(SL_DD) {
		var SL_Kq = this.getUniqueId();

		this.SL_Oq[SL_Kq] = SL_DD;

		return "getSubscriber(" + SL_Kq + ")";
	};

	
	this.getId = function() {
		if (this.SL_Ot == null)
		{
			this.SL_Ot = SL4B_Accessor.getConfiguration().getFrameId();
		}
		return this.SL_Ot;
	};

	
	this.getListenerPrefix = function() {
		if (this.SL_Ow == null)
		{
			this.SL_Ow = "SL4B_SubscriptionManagerAccessor.getSubscriptionManager(\"" + this.getId() + "\").";
		}
		return this.SL_Ow;
	};

	
	this.getLocalListenerPrefix = function() {
		return "SL4B_SubscriptionManager.";
	};

	
	this.getUniqueId = function() {
		return this.SL_PA++;
	};

	
	this.ready = function() {
		if (!this.SL_PP)
		{
			this.SL_PP = true;

						for (var SL_Kr = 0; SL_Kr < this.SL_Oq.length; ++SL_Kr)
			{
				try
				{
					this.SL_Oq[SL_Kr].ready();
				}
				catch (e)
				{
					SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "SubscriptionManager.ready: Exception thrown by a subscriber whilst invoking its ready method; exception was {0}", SL4B_Accessor.getBrowserAdapter().convertExceptionToString(e));
				}
			}
		}
	};

	
	this.isReady = function() {
		return this.SL_PP;
	};
};




function SL_AZ()
{
}

SL_AZ.prototype = new SL4B_AbstractSubscriber;


SL_AZ.prototype.getSubscriber = function(SL_Kq) {
	return this;
};


SL_AZ.prototype.ready = function() { };


SL_AZ.prototype.WTChat = function(SL_AMa, SL_GZ, SL_ALx, SL_EE, SL_AMA) { };


SL_AZ.prototype.WTContribOk = function(SL_AMa) { };


SL_AZ.prototype.WTContribFailed = function(SL_AMa, SL_AMb) { };


SL_AZ.prototype.WTdirUpdated = function(SL_FW, SL_AMa, SL_HI, SL_Gk) { };


SL_AZ.prototype.WTDirMultiUpdated = function(SL_FW, SL_FX) { };


SL_AZ.prototype.WTFieldDeleted = function(SL_AMa, SL_Ik, SL_AMT) { };


SL_AZ.prototype.WTType2Clear = function(SL_AMa) { };


SL_AZ.prototype.WTType3Clear = function(SL_AMa) { };


SL_AZ.prototype.WTNewsUpdated = function(SL_AMa, SL_ALs, SL_ALk, SL_ALl) { };


SL_AZ.prototype.WTObjectDeleted = function(SL_AMa) { };


SL_AZ.prototype.WTObjectInfo = function(SL_AMa, SL_HI, SL_Fl, SL_ALa) { };


SL_AZ.prototype.WTObjectNotFound = function(SL_AMa) { };


SL_AZ.prototype.WTObjectNotStale = function(SL_AMa, SL_Ik) { };


SL_AZ.prototype.WTObjectReadDenied = function(SL_AMa) { };


SL_AZ.prototype.WTObjectStale = function(SL_AMa, SL_Ik) { };


SL_AZ.prototype.WTObjectStatus = function(SL_AMa, SL_HI, SL_HJ, SL_EE) { };


SL_AZ.prototype.WTObjectType = function(SL_AMa, SL_AMD, SL_AME) { };


SL_AZ.prototype.WTObjectUnavailable = function(SL_AMa) { };


SL_AZ.prototype.WTObjectUpdated = function(SL_AMa) { };


SL_AZ.prototype.WTObjectWriteDenied = function(SL_AMa) { };


SL_AZ.prototype.WTPageUpdated = function(SL_AMa, SL_GG, SL_GH, SL_GI, SL_GJ) { };


SL_AZ.prototype.WTRecordMultiUpdated = function(SL_AMa, SL_FX) { };


SL_AZ.prototype.WTRecordUpdated = function(SL_AMa, SL_Ik, SL_ALa) { };


SL_AZ.prototype.WTStoryReset = function(SL_AMa) {  };


SL_AZ.prototype.WTStoryUpdated = function(SL_AMa, SL_JJ) { };


SL_AZ.prototype.WTStructureChange = function(SL_JK, SL_AMa, SL_JM, SL_Gk) { };


SL_AZ.prototype.WTPermissionUpdated = function(SL_AMa, SL_JP, SL_FX) { };


SL_AZ.prototype.WTPermissionDeleted = function(SL_AMa, SL_JP) { };






SL4B_SubscriptionManagerAccessor = new function() {
	
	this.SL_PP = false;

	
	this.SL_PR = new Object();

	
	this.SL_PI = new SL_AZ();

	
	this.getSubscriptionManager = function(SL_JT) {
		var SL_Ks = this.SL_PR[SL_JT];
		if (typeof SL_Ks == "undefined")
		{
						SL4B_Logger.log(SL4B_DebugLevel.WARN, "AbstractSubscriber.getSubscriptionManager: No subscription manager has been registered with the id \"{0}\". Using null subscription manager.", SL_JT);
			SL_Ks = this.SL_PI;
		}
		return SL_Ks;
	};

	
	this.addSubscriptionManager = function(SL_Ks) {
		if (typeof this.SL_PR[SL_Ks.getId()] != "undefined")
		{
						SL4B_Logger.log(SL4B_DebugLevel.const_ERROR_INT, "AbstractSubscriber.addSubscriptionManager: A subscription manager with the identifier \"{0}\" has already been registered", SL_Ks.getId());
		}
		else
		{
						this.SL_PR[SL_Ks.getId()] = SL_Ks;

						if (this.SL_PP)
			{
				SL_Ks.ready();
			}
		}
	};

	
	this.removeSubscriptionManager = function(SL_Ks) {
		delete(this.SL_PR[SL_Ks.getId()]);
	};

	
	this.ready = function() {
		if (!this.SL_PP)
		{
			this.SL_PP = true;

						for (var SL_Kt in this.SL_PR)
			{
				this.SL_PR[SL_Kt].ready();
			}
		}
	};
};




SL4B_ObjectStatus = new function() {
	
	this.OK = 3;

	
	this.STALE = 1;

	
	this.LIMITED = 5;

	
	this.REMOVED = 2;

	
	this.INFO = 0;

	
	this.SL_PT = new Array( this.OK, this.STALE, this.LIMITED, this.REMOVED, this.INFO );

	
	this.RTTP_STATUS_CODE_BASELINE = 415;

	
	this.getObjectStatusFromRttpCode = function(SL_EF) { 
		var SL_Ku = SL_EF - this.RTTP_STATUS_CODE_BASELINE; 
		if(SL_Ku >= 0 && SL_Ku < this.SL_PT.length)
		{
			return this.SL_PT[SL_Ku];
		}
		else
		{
			throw new SL4B_Exception("Invalid RTTP status code. Code was "+SL_EF);
		}
	};
};




SL4B_ChatStatus = new function() {
	
	this.MESSAGE = 0;

	
	this.USER_SUBSCRIBED = 1;

	
	this.USER_UNSUBSCRIBED = 2;

	
	this.SUBSCRIBED = 3;
};



function SL4B_ExceptionHandler()
{
}

SL4B_ExceptionHandler.prototype.processError = SL_Ab;
SL4B_ExceptionHandler.prototype.processException = SL_Ac;


function SL_Ab(SL_JX)
{
	throw (SL_JX);
}


function SL_Ac(SL_BT)
{
	throw (SL_BT);
}


function SL4B_SilentExceptionHandler()
{
}

SL4B_SilentExceptionHandler.prototype.processError = SL_Ae;
SL4B_SilentExceptionHandler.prototype.processException = SL_Af;


function SL_Ae(SL_JX)
{
		SL4B_Logger.log(SL4B_DebugLevel.const_CRITICAL_INT, SL_JX.toString());
}


function SL_Af(SL_BT)
{
		SL4B_Logger.log(SL4B_DebugLevel.const_CRITICAL_INT, SL_BT.toString());
}

function sl4b_exception_handler_scriptLoaded()
{
	SL4B_Accessor.setExceptionHandler(new SL4B_ExceptionHandler());
}




C_CallbackQueue = new function()
{
	
	this.SL_AGJ = new Array();

	
	this.SL_Pb = 250;

	
	this.SL_Pa = 5000;

	
	this.start = function() {
		var SL_Jm = SL4B_Accessor.getConfiguration();

		this.SL_Pb = SL_Jm.getCallbackBatchFrequency();
		this.SL_Pa = SL_Jm.getMaximumCallbackBatchSize();

		setTimeout("C_CallbackQueue.processCallbackBatch();", this.SL_Pb);
	};

	
	this.addCallback = function(SL_Jb) {
		this.SL_AGJ.push(SL_Jb);
	};

	
	this.processCallbackBatch = function() {
		var SL_Kw = (new Date()).valueOf();
		var SL_Kx = 0;
		while (this.SL_AGJ.length > 0 && SL_Kx < this.SL_Pa)
		{
			++SL_Kx;

			var SL_Jb = this.SL_AGJ.shift();
						this.invokeCallback(SL_Jb);
		}

		var SL_LA = (new Date()).valueOf() - SL_Kw;
		setTimeout("C_CallbackQueue.processCallbackBatch();", Math.max(0, this.SL_Pb - SL_LA));
	};

	
	this.invokeCallback = function(SL_Jb) {
		if (!SL_Jb || typeof SL_Jb != "object" || typeof SL_Jb.length != "number")
		{
			SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "CallbackQueue.invokeCallback: Error processing callback \"{0}\"; Specified callback parameter is not an array", ((SL_Jb && typeof SL_Jb.join == "function")?SL_Jb.join():SL_Jb));
		}
		else if (SL_Jb.length < 2)
		{
			SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "CallbackQueue.invokeCallback: Error processing callback \"{0}\"; Unexpected number of callback arguments ({1})", ((SL_Jb && typeof SL_Jb.join == "function")?SL_Jb.join():SL_Jb), SL_Jb.length);
		}
		else
		{
			var SL_LB = SL_Jb.shift();
			var SL_LC = SL_Jb.shift();
			try
			{
				SL_LB[SL_LC].apply(SL_LB, SL_Jb);
			}
			catch (e)
			{
				SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "CallbackQueue.invokeCallback: Error processing callback for object \"{0}\" (method: \"{1}\", parameters: \"{2}\"; Unexpected exception ({3})", SL_LB, SL_LC, ((SL_Jb && typeof SL_Jb.join == "function")?SL_Jb.join():SL_Jb), SL4B_Accessor.getBrowserAdapter().convertExceptionToString(e));
			}
		}
	};
};



SL4B_WindowEventHandler = new function()
{
	
	this.SL_Ph = new Array();

	
	this.addListener = function(SL_Jd) {
				if (typeof SL_Jd.onLoad == "function" || typeof SL_Jd.onUnload == "function")
		{
						this.SL_Ph.push(SL_Jd);
		}
		else
		{
			throw new SL4B_Exception("addListener: listener object must implement either the onLoad or onUnload methods");
		}
	};

	
	this.initialise = function() {
				SL4B_Accessor.getBrowserAdapter().addEventListener(window, "load", SL_Ah);
		SL4B_Accessor.getBrowserAdapter().addEventListener(window, "beforeunload", SL_Aj);
	};

	
	this.onLoad = function(SL_BK) {
		SL4B_Logger.log(SL4B_DebugLevel.const_INFO_INT, "WindowEventHandler.onLoad: method invoked");

		SL_BK = this.getEvent(SL_BK);

				for(var SL_Kd = 0; SL_Kd < this.SL_Ph.length; SL_Kd++)
		{
			var SL_Jd = this.SL_Ph[SL_Kd];
			if (typeof SL_Jd.onLoad == "function")
			{
								SL_Jd.onLoad(SL_BK);
			}
		}
	};

	
	this.onBeforeUnload = function(SL_BK) {
		SL4B_Logger.log(SL4B_DebugLevel.const_INFO_INT, "WindowEventHandler.onBeforeUnload: method invoked");

		SL_BK = this.getEvent(SL_BK);

				for(var SL_Kd = 0; SL_Kd < this.SL_Ph.length; SL_Kd++)
		{
			var SL_Jd = this.SL_Ph[SL_Kd];
			if (typeof SL_Jd.onUnload == "function")
			{
								SL_Jd.onUnload(SL_BK);
			}
		}
	};

	
	this.getEvent = function(SL_BK) {
		return ((typeof SL_BK == "undefined")?((typeof event != "undefined")?event:null):SL_BK);
	};

	this.initialise();
};


function SL_Ah(SL_BK)
{
	SL4B_WindowEventHandler.onLoad(SL_BK);
}


function SL_Aj(SL_BK)
{
	SL4B_WindowEventHandler.onBeforeUnload(SL_BK);
}


 
SL4B_XmlResponseRetriever = new function()
{

	
	this.getXmlDocumentElement = function(SL_AKZ)
	{
		var l_oDocElement = null;
		try
		{
			l_oDocElement = SL_AKZ.responseXML.documentElement;
		}
		catch (e)
		{
						if (e.match(/Permission/) && SL_AKZ.responseText && document.implementation.createDocument)
			{
				var l_oParser = new DOMParser();
				var l_oDomDoc = l_oParser.parseFromString(SL_AKZ.responseText,"text/xml");
				l_oDocElement = l_oDomDoc.documentElement;
			}
		}
		return l_oDocElement;
	}
	
};




GF_CommonDomainExtractor = new function()
{
	
	this.SL_Pr = false;
	
	
	this.SL_Ps = null;

	this.getCommonDomain = LF_CommonDomainExtractor_GetCommonDomain;
	this.getLiberatorUrl = LF_CommonDomainExtractor_GetLiberatorUrl;
	this.determineCommonDomain = LF_CommonDomainExtractor_DetermineCommonDomain;
	this.getCommonDomainForDifferentPort = LF_CommonDomainExtractor_GetCommonDomainForDifferentPorts;
	this.getDocumentDomain = LF_CommonDomainExtractor_GetDocumentDomain;
};


function LF_CommonDomainExtractor_GetCommonDomain()
{
	if (!this.SL_Pr)
	{
		this.SL_Ps = this.determineCommonDomain(this.getDocumentDomain());
		this.SL_Pr = true;
	}
	return this.SL_Ps;
}


function LF_CommonDomainExtractor_GetLiberatorUrl()
{
	var SL_KA = SL4B_Accessor.getConfiguration().getJsContainerUrl();
	if (SL_KA == null)
	{
		SL_KA = SL4B_Accessor.getConfiguration().getServerUrl();
	}
	return SL_KA;
}


function LF_CommonDomainExtractor_DetermineCommonDomain(l_sWebPageDomain, l_sWebServerHref)
{
		var l_oLiberatorDomainMatch = this.getLiberatorUrl().match(/https?:\/\/([^\/:]+)/);

	if (l_oLiberatorDomainMatch == null)
	{
						SL4B_Logger.log(SL4B_DebugLevel.const_NOTIFY_INT, "CommonDomainExtractor.determineCommonDomain: Relative url to Liberator detected - document.domain will not be set");
		return null;
	}
	else if (l_sWebPageDomain == l_oLiberatorDomainMatch[1])
	{
		if(SL4B_Accessor.getBrowserAdapter().isFirefox())
		{
						var l_pLibPortMatch = this.getLiberatorUrl().match(/^https?:\/\/([^:]+)(:)?(\d+)/);

						if(l_sWebServerHref == null)
			{
				l_sWebServerHref = "http://localhost:80/"; 	
			}
			var l_pServerPortMatch = l_sWebServerHref.match(/^https?:\/\/([^:]+)(:)?(\d+)/);

						if((l_pLibPortMatch != null ) )
			{
				
								if((l_pServerPortMatch != null && l_pLibPortMatch[3] != l_pServerPortMatch[3] ) || ( l_pServerPortMatch == null && l_pLibPortMatch[3] != "80" ))
				{
					return this.getCommonDomainForDifferentPort(l_sWebPageDomain);
				}
			}
			else if(l_pServerPortMatch != null && l_pServerPortMatch[3] != "80")
			{
								return this.getCommonDomainForDifferentPort(l_sWebPageDomain);
			}
		}
						SL4B_Logger.log(SL4B_DebugLevel.const_NOTIFY_INT, "JavaScriptRttpProvider.determineCommonDomain: Web page and Liberator share the same domain ({0}) - document.domain will not be set", l_sWebPageDomain);
		return null;
	}

		var l_pWebPageDomainParts = l_sWebPageDomain.split(".");
	var l_pLiberatorDomainParts = l_oLiberatorDomainMatch[1].split(".");

			var l_nWebPageIndex = l_pWebPageDomainParts.length - 1;
	var l_nLiberatorIndex = l_pLiberatorDomainParts.length - 1;

	if (l_nWebPageIndex < 1 || l_nLiberatorIndex < 1)
	{
						SL4B_Logger.log(SL4B_DebugLevel.const_CRITICAL_INT, "JavaScriptRttpProvider.determineCommonDomain: Web page and Liberator do not share the common domain (web page domain = {0}, liberator domain = {1})", l_sWebPageDomain, l_oLiberatorDomainMatch[1]);
		throw new SL4B_Exception("determineCommonDomain [1]: web page and Liberator do not share a common domain, connection to Liberator cannot be established");
	}

	var l_nMatchingParts = 0;
	for ( ; l_nWebPageIndex >= 0 && l_nLiberatorIndex >= 0; --l_nWebPageIndex, --l_nLiberatorIndex)
	{
		if (l_pWebPageDomainParts[l_nWebPageIndex] == l_pLiberatorDomainParts[l_nLiberatorIndex])
		{
			++l_nMatchingParts;
		}
		else
		{
						break;
		}
	}

	if (l_nMatchingParts < 2)
	{
						SL4B_Logger.log(SL4B_DebugLevel.const_CRITICAL_INT, "CommonDomainExtractor.determineCommonDomain: Web page and Liberator do not share the common domain (web page domain = {0}, liberator domain = {1})", l_sWebPageDomain, l_oLiberatorDomainMatch[1]);
		throw new SL4B_Exception("determineCommonDomain [2]: web page and Liberator do not share a common domain, connection to Liberator cannot be established");
	}

		var l_pCommonDomain = l_pWebPageDomainParts.splice(l_pWebPageDomainParts.length - l_nMatchingParts, l_nMatchingParts);
	var SL_Bd = l_pCommonDomain.join(".");

	SL4B_Logger.log(SL4B_DebugLevel.const_NOTIFY_INT, "CommonDomainExtractor.determineCommonDomain: document.domain will be set to {0}", SL_Bd);
	return SL_Bd;
}


function LF_CommonDomainExtractor_GetCommonDomainForDifferentPorts(l_sWebPageDomain)
{
	SL4B_Logger.log(SL4B_DebugLevel.const_NOTIFY_INT, "CommonDomainExtractor.getCommonDomainForDifferentPorts: web page and Liberator share the same domain ({0}), but their ports differ and domain needs to be changed.", l_sWebPageDomain);
			var SL_Bd = l_sWebPageDomain.substring(l_sWebPageDomain.indexOf(".")+1);
	SL4B_Logger.log(SL4B_DebugLevel.const_NOTIFY_INT, "CommonDomainExtractor.getCommonDomainForDifferentPorts: document.domain will be set to {0}.", SL_Bd);
	return SL_Bd;
}


function LF_CommonDomainExtractor_GetDocumentDomain()
{
	return document.domain;
}



function SL4B_Configuration()
{
	
	this.SL_RR = SL4B_ScriptLoader.getIndexScript();

	
	this.SL_Pw = false;

	
	this.SL_Rc = false;

	
	this.SL_Py = new Array("2", "3");

	
	this.SL_QA = new Array("5", "3");

	
	this.SL_RA = new Object();

		this.SL_RA["appletjar"] = "applet.jar";
	this.SL_RA["user"] = "demouser";
	this.SL_RA["password"] = "demopass";
	this.SL_RA["credentialsprovider"] = SL4B_ScriptLoader.const_STANDARD_CREDENTIALS_PROVIDER;
	this.SL_RA["rttpprovider"] = SL4B_ScriptLoader.const_JAVASCRIPT_RTTP_PROVIDER;
	this.SL_RA["appletchecktimeout"] = 15000;
	this.SL_RA["rttpapplettimeout"] = 120000;
	this.SL_RA["debug"] = SL4B_DebugLevel.CRITICAL;
	this.SL_RA["rttpdebuglevel"] = SL4B_DebugLevel.CRITICAL;
	this.SL_RA["debugwindowtype"] = SL4B_Logger.const_HTML;
	this.SL_RA["keymasterurl"] = null;
	this.SL_RA["applicationid"] = null;
	this.SL_RA["discarddelay"] = 10;
	this.SL_RA["jvmfileurl"] = "http://www.caplin.com/products/jvm-list.js";
	this.SL_RA["jvmfiledownloadtimeout"] = 10;
	this.SL_RA["logoutdelay"] = 1;
	this.SL_RA["objectnamedelimiter"] = " ";
	this.SL_RA["statsinterval"] = 5;
	this.SL_RA["statsreset"] = 5000;
	this.SL_RA["statstimeout"] = 30000;
	this.SL_RA["useconfig"] = "server_config.js";
	this.SL_RA["updatebatchfreq"] = 250;
	this.SL_RA["maxupdatebatchsize"] = 5000;
	this.SL_RA["gcfreq"] = 200;
	this.SL_RA["jscontainerpath"] = "sl4b/javascript-rttp-provider";
	this.SL_RA["appletpath"] = "applet";
	this.SL_RA["type3pollperiod"] = 1000;
	this.SL_RA["type5reconnectcount"] = 10000;
	this.SL_RA["type5padlength"] = 1024 * 4; 	this.SL_RA["maxgetlength"] = 128;
	this.SL_RA["connectiontimeout"] = 15000;
	this.SL_RA["service"] = null;
	this.SL_RA["keymasterconnectiontimeout"] = 10000;
	this.SL_RA["keymasterkeepaliveinterval"] = 30000;
	this.SL_RA["commondomain"] = null;
	
		this.SL_RA["flashtime"] = 1000;
	this.SL_RA["bg"] = null;
	this.SL_RA["bgchange"] = 'rel';
	this.SL_RA["bgdn"] = 'red';
	this.SL_RA["bgeq"] = 'green';
	this.SL_RA["bgup"] = 'blue';
	this.SL_RA["fg"] = null;
	this.SL_RA["fgchange"] = null;
	this.SL_RA["fgdn"] = 'red';
	this.SL_RA["fgeq"] = 'black';
	this.SL_RA["fgflash"] = 'white';
	this.SL_RA["fgup"] = 'blue';
	this.SL_RA["plus"] = null;
	this.SL_RA["fractionhandling"] = null;
	this.SL_RA["gfxup"] = null;
	this.SL_RA["gfxdn"] = null;
 	this.SL_RA["gfxeq"] = null;
	this.SL_RA["isencoded"] = 0;
	this.SL_RA["todp"] = 0;
	this.SL_RA["round"] = 'default';
	this.SL_RA["addcommas"] = 0;
	this.SL_RA["tosf"] = null;
	
		var l_sDefaultServerUrl;
	var SL_AKf = this.SL_RR.src.match(/((^https?:\/\/[^\/]+\/)|(^(..\/)+))/);
	if (SL_AKf != null)
	{
		if (window.location.href.indexOf(SL_AKf[0]) == 0)
		{
												l_sDefaultServerUrl = this.SL_RR.src.replace(/((sl4b)|(rtsl)|(rtml))\/?$/, "");
		}
		else
		{
			l_sDefaultServerUrl = SL_AKf[0];
		}
	}
	else
	{
		l_sDefaultServerUrl = "/";
	}
	this.SL_RA["serverurl"] = l_sDefaultServerUrl;
}

SL4B_Configuration.prototype.getScriptTagAttribute = LF_Configuration_GetScriptTagAttribute;
SL4B_Configuration.prototype.getIntegerScriptTagAttribute = LF_Configuration_GetIntegerScriptTagAttribute;
SL4B_Configuration.prototype.getPositiveIntegerScriptTagAttribute = LF_Configuration_GetPositiveIntegerScriptTagAttribute;
SL4B_Configuration.prototype.getIntegerScriptTagAttributeInMilliseconds = LF_Configuration_GetIntegerScriptTagAttributeInMilliseconds;


SL4B_Configuration.prototype.unaryScriptTagAttributeExists = function(l_sAttribute) { return (this.getScriptTagAttribute(l_sAttribute) != null); };


SL4B_Configuration.prototype.setAttribute = function(l_sAttribute, SL_ALa) { this.SL_Rc = true; this.SL_RA[l_sAttribute.toLowerCase()] = SL_ALa; };


SL4B_Configuration.prototype.getAttribute = function(l_sAttribute) { l_sAttribute = l_sAttribute.toLowerCase(); return ((typeof this.SL_RA[l_sAttribute] == "undefined")?null:this.SL_RA[l_sAttribute]) };


SL4B_Configuration.prototype.getAppletPath = function() {
	var SL_ALa = this.SL_RR.getAttribute("appletpath");
	if (SL_ALa == null)
	{
						SL_ALa = this.getAttribute("appletpath");
	}
	return SL_ALa.replace(/(^\/)/, "").replace(/\/$/, "");
};


SL4B_Configuration.prototype.getAppletUrl = function() {
	var SL_ALa = this.SL_RR.getAttribute("appleturl");
	if (SL_ALa == null)
	{
						SL_ALa = this.getAttribute("appleturl");
	}
	return ((SL_ALa == null)?null:SL_ALa.replace(/\/$/, ""));
};


SL4B_Configuration.prototype.getJsContainerPath = function() {
	var SL_ALa = this.SL_RR.getAttribute("jscontainerpath");
	if (SL_ALa == null)
	{
						SL_ALa = this.getAttribute("jscontainerpath");
	}
	return SL_ALa.replace(/(^\/)/, "").replace(/\/$/, "");
};


SL4B_Configuration.prototype.getJsContainerUrl = function() {
	var SL_ALa = this.SL_RR.getAttribute("jscontainerurl");
	if (SL_ALa == null)
	{
						SL_ALa = this.getAttribute("jscontainerurl");
	}
	return ((SL_ALa == null)?null:SL_ALa.replace(/\/$/, ""));
};


SL4B_Configuration.prototype.getServerUrl = function() {
	var l_sServerUrl = this.getScriptTagAttribute("serverurl");
	if (l_sServerUrl.match(/\/$/) == null)
	{
		l_sServerUrl += "/";
	}
	return l_sServerUrl;
};


SL4B_Configuration.prototype.getAppletJarName = function() { return this.getScriptTagAttribute("appletjar"); };


SL4B_Configuration.prototype.getUsername = function() { return this.getScriptTagAttribute("user"); };


SL4B_Configuration.prototype.getPassword = function() { return this.getScriptTagAttribute("password"); };


SL4B_Configuration.prototype.includeRtsl = function() { return this.unaryScriptTagAttributeExists("includertsl"); };


SL4B_Configuration.prototype.includeRtml = function() { return this.unaryScriptTagAttributeExists("includertml"); };


SL4B_Configuration.prototype.isMasterFrame = function() { return !this.unaryScriptTagAttributeExists("usemasterframe"); };


SL4B_Configuration.prototype.isMultiSource = function() {  return this.unaryScriptTagAttributeExists("multisource");  };



SL4B_Configuration.prototype.getService = function() { return this.getScriptTagAttribute("service"); };



SL4B_Configuration.prototype.getKeyMasterConnectionTimeout = function() { return this.getScriptTagAttribute("keymasterconnectiontimeout"); };


SL4B_Configuration.prototype.getKeyMasterKeepAliveInterval = function() { return this.getScriptTagAttribute("keymasterkeepaliveinterval"); };


SL4B_Configuration.prototype.getFrameId = function() {
	var SL_JT;
	if (this.isMasterFrame())
	{
		SL_JT = "master";
	}
	else
	{
		SL_JT = this.getScriptTagAttribute("frameid");
		if (SL_JT == null)
		{
			SL_JT = this.getFrameLocation();
			if (SL_JT == null)
			{
				SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "Configuration.getFrameId: The slave frame did not have a id defined on it. This identifier is required for the master/slave functionality to work.");
			}
		}
	}
	return SL_JT;
};


SL4B_Configuration.prototype.getFrameLocation = function() { return this.getScriptTagAttribute("thisframe"); };


SL4B_Configuration.prototype.getMasterFrameLocation = function() { return this.getScriptTagAttribute("usemasterframe"); };


SL4B_Configuration.prototype.getCredentialsProvider = function() { 
	if (this.getKeyMasterUrl() == null || this.getKeyMasterUrl() == "")
	{
		return this.getScriptTagAttribute("credentialsprovider"); 
	}
	else
	{
		return SL4B_ScriptLoader.const_KEYMASTER_CREDENTIALS_PROVIDER;
	}
};


SL4B_Configuration.prototype.getParameterFromQueryString = function (l_sParameterName) {
	var SL_BJ = null;
	
	try
	{
		var l_oNextWindow;
				do
		{
			l_oNextWindow = (l_oNextWindow) ? l_oNextWindow.parent : window;
			SL_BJ = this.getParameterFromProvidedQueryString(l_oNextWindow.location.href, l_sParameterName);
		} while((!SL_BJ) && (l_oNextWindow.parent != l_oNextWindow));
	}
	catch(e)
					{
			}
	
	return SL_BJ;
};


SL4B_Configuration.prototype.getParameterFromProvidedQueryString = function (l_sQueryString, l_sParameterName) {
	var l_oMatches = l_sQueryString.match(new RegExp("[?&]" + l_sParameterName + "=([^&#]+)"));
	
	return (l_oMatches) ? l_oMatches[1] : null;
};


SL4B_Configuration.prototype.getDebugLevel = function() {
	var SL_BJ = this.getParameterFromQueryString("debug");
	
	return (SL_BJ) ? SL_BJ : this.getScriptTagAttribute("debug");
};


SL4B_Configuration.prototype.getRttpDebugLevel = function() {
	var SL_BJ = this.getParameterFromQueryString("rttpdebuglevel");
	
	return (SL_BJ) ? SL_BJ : this.getScriptTagAttribute("rttpdebuglevel");
};


SL4B_Configuration.prototype.getAppletCheckTimeout = function() { return this.getIntegerScriptTagAttribute("appletchecktimeout"); };


SL4B_Configuration.prototype.getRttpAppletTimeout = function() { return this.getIntegerScriptTagAttribute("rttpapplettimeout"); };

SL4B_Configuration.prototype.includeFlash = LF_Configuration_IncludeFlash;
SL4B_Configuration.prototype.getRttpProvider = LF_Configuration_GetRttpProvider;
SL4B_Configuration.prototype.getDebugWindowType = LF_Configuration_GetDebugWindowType;
SL4B_Configuration.prototype.getCommonDomain = LF_Configuration_GetCommonDomain;
SL4B_Configuration.prototype.loadConfigurationFile = LF_Configuration_LoadConfigurationFile;
SL4B_Configuration.prototype.loaded = LF_Configuration_Loaded;

SL4B_Configuration.prototype.getConnectionTypes = LF_Configuration_GetConnectionTypes;
SL4B_Configuration.prototype.getType3PollPeriod = LF_Configuration_GetType3PollPeriod;
SL4B_Configuration.prototype.getType5ReconnectCount = LF_Configuration_GetType5ReconnectCount;
SL4B_Configuration.prototype.getType5PadLength = LF_Configuration_GetType5PadLength;
SL4B_Configuration.prototype.getConnectionTimeout = LF_Configuration_GetConnectionTimeout;
SL4B_Configuration.prototype.getMaxGetLength = LF_Configuration_GetMaxGetLength;


SL4B_Configuration.prototype.getApplicationId = function() {
	var l_sClientApplicationId = this.getScriptTagAttribute("applicationid");
	return "SL4B" + ((l_sClientApplicationId == null || l_sClientApplicationId == "")?"":":" + l_sClientApplicationId);
};


SL4B_Configuration.prototype.getDiscardDelay = function() { return this.getIntegerScriptTagAttribute("discarddelay"); };


SL4B_Configuration.prototype.getJvmFileUrl = function() { return this.getScriptTagAttribute("jvmfileurl"); };


SL4B_Configuration.prototype.getJvmFileDownloadTimeout = function() { return this.getIntegerScriptTagAttribute("jvmfiledownloadtimeout"); };


SL4B_Configuration.prototype.getLogoutDelay = function() { return this.getIntegerScriptTagAttribute("logoutdelay"); };



SL4B_Configuration.prototype.getObjectNameDelimiter = function() { return this.getScriptTagAttribute("objectnamedelimiter"); };



SL4B_Configuration.prototype.getStatsInterval = function() { return this.getIntegerScriptTagAttributeInMilliseconds("statsinterval"); };



SL4B_Configuration.prototype.getStatsReset = function() { return this.getIntegerScriptTagAttributeInMilliseconds("statsreset"); };



SL4B_Configuration.prototype.getStatsTimeout = function() { return this.getIntegerScriptTagAttributeInMilliseconds("statstimeout"); };


SL4B_Configuration.prototype.getKeyMasterUrl = function() { return this.getScriptTagAttribute("keymasterurl"); };


SL4B_Configuration.prototype.getUseConfig = function() { return this.getScriptTagAttribute("useconfig"); };


SL4B_Configuration.prototype.getGarbageCollectionFrequency = function() { return this.getPositiveIntegerScriptTagAttribute("gcfreq"); };


SL4B_Configuration.prototype.getMicrosoftGarbageCollectionFrequency = function() { return this.getPositiveIntegerScriptTagAttribute("gcfreqms"); };


SL4B_Configuration.prototype.getSunGarbageCollectionFrequency = function() { return this.getPositiveIntegerScriptTagAttribute("gcfreqsun"); };


SL4B_Configuration.prototype.getCallbackBatchFrequency = function() { return this.getPositiveIntegerScriptTagAttribute("updatebatchfreq"); };


SL4B_Configuration.prototype.getMaximumCallbackBatchSize = function() { return this.getPositiveIntegerScriptTagAttribute("maxupdatebatchsize"); };


SL4B_Configuration.prototype.isNoStaleNotify = function() {return this.unaryScriptTagAttributeExists("nostalenotify"); };


SL4B_Configuration.prototype.isNoBrowserStatus = function() {return this.unaryScriptTagAttributeExists("nobrowserstatus"); };


SL4B_Configuration.prototype.isNoStats = function() {return this.unaryScriptTagAttributeExists("nostats"); };


SL4B_Configuration.prototype.isPortlet = function() {return this.unaryScriptTagAttributeExists("portlet"); };


SL4B_Configuration.prototype.isDisableJvmDownload = function() {return this.unaryScriptTagAttributeExists("disablejvmdownload"); };


SL4B_Configuration.prototype.isMultiUpdates = function() {return this.unaryScriptTagAttributeExists("multiupdates"); };


SL4B_Configuration.prototype.isUseStaticHtmlFailoverContainers = function() {return this.unaryScriptTagAttributeExists("usestatichtmlfailovercontainers"); };


SL4B_Configuration.prototype.isDirectEnable = function() {return this.unaryScriptTagAttributeExists("directEnable"); };


SL4B_Configuration.prototype.isHttpEnable = function() {return this.unaryScriptTagAttributeExists("httpEnable"); };


SL4B_Configuration.prototype.isRefreshEnable = function() {return this.unaryScriptTagAttributeExists("refreshEnable"); };


SL4B_Configuration.prototype.getContainerFrameLocation = function() {
	var l_sCommonContainerFrame = this.getScriptTagAttribute("containerframelocation");
	if (l_sCommonContainerFrame == null)
	{
		var l_sMasterFrameLocation = this.getMasterFrameLocation();
		if (l_sMasterFrameLocation != null && l_sMasterFrameLocation != "")
		{
			var SL_AKf = l_sMasterFrameLocation.match(/(((window)|(self)|(parent)|(top)|(opener))(\.|$))*/);
			if (SL_AKf != null && SL_AKf[0] != "")
			{
				l_sCommonContainerFrame = SL_AKf[0].replace(/\.$/, "");
			}
			else
			{
				l_sCommonContainerFrame = "top";
			}
		}
		else
		{
						l_sCommonContainerFrame = "top";
		}
	}
	return l_sCommonContainerFrame;
};


function LF_Configuration_GetScriptTagAttribute(l_sAttribute)
{
	l_sAttribute = l_sAttribute.toLowerCase();
	var SL_ALa = this.SL_RR.getAttribute(l_sAttribute);
	if (SL_ALa == null)
	{
		SL_ALa = this.getAttribute(l_sAttribute);
	}
	return SL_ALa;
}


function LF_Configuration_GetIntegerScriptTagAttribute(l_sAttribute)
{
	l_sAttribute = l_sAttribute.toLowerCase();
	var l_nIntegerValue = this.getAttribute(l_sAttribute);
	var SL_ALa = this.SL_RR.getAttribute(l_sAttribute);
	
	if(this.checkInteger(SL_ALa) == true) {
		l_nIntegerValue = parseInt(SL_ALa);
	}
	
	return l_nIntegerValue;
}


SL4B_Configuration.prototype.checkInteger = function(SL_ALa) {
	var isValid = false;
	
	if (SL_ALa !== null && !isNaN(SL_ALa))
	{
				var l_nTestValue = parseInt(SL_ALa, 10);
		if (l_nTestValue >= 0) {
			isValid = true;
		}
	}
	
	return isValid;
}


function LF_Configuration_GetPositiveIntegerScriptTagAttribute(l_sAttribute)
{
	l_sAttribute = l_sAttribute.toLowerCase();
	var l_nPositiveIntegerValue = this.getAttribute(l_sAttribute);
	var SL_ALa = this.SL_RR.getAttribute(l_sAttribute);
	
	if(this.checkPositiveInteger(SL_ALa) == true) {
		l_nPositiveIntegerValue = parseInt(SL_ALa);
	}
	
	return l_nPositiveIntegerValue;
}


SL4B_Configuration.prototype.checkPositiveInteger = function(SL_ALa) {
	var isValid = false;
	
	if(this.checkInteger(SL_ALa) == true && parseInt(SL_ALa) > 0) {
		isValid = true;
	}
	
	return isValid;
}


function LF_Configuration_GetIntegerScriptTagAttributeInMilliseconds(l_sAttribute)
{
	l_sAttribute = l_sAttribute.toLowerCase();
	var l_nAttributeValue = this.getIntegerScriptTagAttribute(l_sAttribute); 
	if(l_nAttributeValue == null)
	{
				l_nAttributeValue = this.getAttribute(l_sAttribute);
	}
	else if(l_nAttributeValue < 500)
	{
		l_nAttributeValue = l_nAttributeValue * 1000;
	}
	return l_nAttributeValue;
}


function LF_Configuration_IncludeFlash()
{
	return (this.includeRtml() || this.unaryScriptTagAttributeExists("enableflash"));
}


function LF_Configuration_GetConnectionTypes()
{
	var SL_ALa = this.getScriptTagAttribute("connectiontypes");
	var l_pConnectionTypes;

	if (SL_ALa != null)
	{
		l_pConnectionTypes = SL_ALa.split(",");
	}
	else
	{
						if (this.isDirectEnable() || this.isHttpEnable() || this.isRefreshEnable())
		{
			var l_pConnectionTypes = new Array();
			if (this.getRttpProvider() == SL4B_ScriptLoader.const_JAVASCRIPT_RTTP_PROVIDER)
			{
				if (this.isRefreshEnable())
				{
					l_pConnectionTypes.push("3");
				}
				else
				{
					l_pConnectionTypes.push("5");
					l_pConnectionTypes.push("3");
				}
			}
			else 			{
				if (this.isDirectEnable())
				{
					l_pConnectionTypes.push("1");
				}
				if (this.isHttpEnable())
				{
					l_pConnectionTypes.push("2");
				}
				if (this.isRefreshEnable())
				{
					l_pConnectionTypes.push("3");
				}
			}
		}
		else 
		{
			if (this.getRttpProvider() == SL4B_ScriptLoader.const_JAVASCRIPT_RTTP_PROVIDER)
			{
				l_pConnectionTypes = this.SL_QA;
			}
			else 			{
				l_pConnectionTypes = this.SL_Py;
			}
		}
	}

	return l_pConnectionTypes;
}


function LF_Configuration_GetType3PollPeriod()
{
   return this.getIntegerScriptTagAttribute("type3pollperiod");
}



function LF_Configuration_GetType5ReconnectCount()
{
	return this.getIntegerScriptTagAttribute("type5reconnectcount");
}


function LF_Configuration_GetType5PadLength()
{
	return this.getIntegerScriptTagAttribute("type5padlength");
}


function LF_Configuration_GetConnectionTimeout()
{
	return this.getPositiveIntegerScriptTagAttribute("connectiontimeout");
}


function LF_Configuration_GetMaxGetLength()
{
	return this.getIntegerScriptTagAttribute("maxgetlength");
}


function LF_Configuration_GetRttpProvider()
{
	return this.getScriptTagAttribute("rttpprovider").toLowerCase();
}


function LF_Configuration_GetDebugWindowType()
{
	return this.getScriptTagAttribute("debugwindowtype");
}


function LF_Configuration_GetCommonDomain()
{
	var SL_Bd = this.getScriptTagAttribute("commondomain");
	if (SL_Bd == null)
	{
				SL_Bd= GF_CommonDomainExtractor.getCommonDomain();
	}
	return SL_Bd;
}


function LF_Configuration_LoadConfigurationFile()
{
	var l_sConfigurationFileUrl = this.getScriptTagAttribute("configurationfile");
	if (l_sConfigurationFileUrl != null)
	{
		this.SL_Pw = true;

				SL4B_ScriptLoader.loadScript(l_sConfigurationFileUrl);

						SL4B_ScriptLoader.loadSl4bScript("configuration/configuration-file-loaded.js");
	}
	else
	{
				this.loaded();
	}
}


function LF_Configuration_Loaded()
{
	if (this.SL_Pw && !this.SL_Rc)
	{
								SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "Configuration.loaded: Specified configuration file was empty. There may have been an error loading the file!");
	}

		SL4B_Logger.printMessage(SL4B_Version.getVersionInfo());

			var l_pMethodNamesToIgnoreSet = new Object();
	l_pMethodNamesToIgnoreSet["getIntegerScriptTagAttributeInMilliseconds"] = true;
	l_pMethodNamesToIgnoreSet["getPositiveIntegerScriptTagAttribute"] = true;
	l_pMethodNamesToIgnoreSet["getIntegerScriptTagAttribute"] = true;
	l_pMethodNamesToIgnoreSet["getScriptTagAttribute"] = true;
	l_pMethodNamesToIgnoreSet["getAttribute"] = true;
	l_pMethodNamesToIgnoreSet["getParameterFromProvidedQueryString"] = true;
	l_pMethodNamesToIgnoreSet["getParameterFromQueryString"] = true;
	
	var l_oConfigurationMethodRegExp = /(^get)|(^is)|(^include)/;
	var l_pMethodNames = new Array();

			for (var l_sMethod in this)
	{
		if (l_sMethod.match(l_oConfigurationMethodRegExp) && !l_pMethodNamesToIgnoreSet[l_sMethod] && typeof this[l_sMethod] == "function")
		{
			l_pMethodNames.push(l_sMethod);
		}
	}
	
		l_pMethodNames.sort();
	
		for (var l_nMethod = 0, SL_AJl = l_pMethodNames.length; l_nMethod < SL_AJl; ++l_nMethod)
	{
		var l_sMethod = l_pMethodNames[l_nMethod];
		SL4B_Logger.printMessage("SL4B configuration [" + l_sMethod + "()]: " + this[l_sMethod]());
	}

		SL4B_ScriptLoader.loadConfiguredScripts(this);
}

function sl4b_configuration_scriptLoaded()
{
			try
	{
		SL4B_Accessor.setConfiguration(new SL4B_Configuration());
	}
	catch(e)
	{
		SL4B_Accessor.getExceptionHandler().processException(e);
	}
	
	
			
	SL4B_Accessor.getConfiguration().loadConfigurationFile();
}




function SL4B_AbstractCredentialsProvider()
{
}


SL4B_AbstractCredentialsProvider.prototype.getCredentials = function(SL_Ar) { throw new SL4B_Error("getCredentials method not implemented"); };


SL4B_AbstractCredentialsProvider.prototype.getUsername = function() { throw new SL4B_Error("getUsername method not implemented"); };



function SL4B_StandardCredentialsProvider()
{
}

SL4B_StandardCredentialsProvider.prototype = new SL4B_AbstractCredentialsProvider;
SL4B_StandardCredentialsProvider.prototype.getCredentials = LF_StandardCredentialsProvider_GetCredentials;
SL4B_StandardCredentialsProvider.prototype.getUsername = LF_StandardCredentialsProvider_GetUsername;


function LF_StandardCredentialsProvider_GetCredentials(SL_Ar)
{
	var SL_Jm = SL4B_Accessor.getConfiguration();
	SL_Ar.login(SL_Jm.getUsername(), SL_Jm.getPassword());
}


function LF_StandardCredentialsProvider_GetUsername()
{
	return SL4B_Accessor.getConfiguration().getUsername();
}



function sl4b_standard_credentials_provider_scriptLoaded()
{
		SL4B_Accessor.setCredentialsProvider(new SL4B_StandardCredentialsProvider());
}




C_DynamicIFrameLoader = new function()
{
	
	document.write("<div id=\"iframeloader\"></div>");
	
   	var l_oIFrameIdentifierToElementMap = new Object();
   	var l_oIFrameIdentifierToTimeoutMap = new Object();

   
	this.loadIFrame = function(l_sIFrameIdentifier, SL_KA, SL_F, SL_D)
	{
		if (typeof SL_F.scriptLoadTimeout != "function")
		{
						throw new SL4B_Exception("C_DynamicIFrameLoader.loadIFrame: l_oErrorCallback parameter must implement scriptLoadTimeout() ");
		}
		
    	SL_KA += ((SL_KA.indexOf("?") == -1)?"?":"&") + "time=" + (new Date()).valueOf();

		var SL_Bd = SL4B_Accessor.getConfiguration().getCommonDomain();
		if (SL_Bd != null)
		{
        	SL_KA += "&" + SL4B_JavaScriptRttpProviderConstants.const_DOMAIN_PARAMETER + "=" + SL_Bd;
		}

		var l_oIFrameElement = l_oIFrameIdentifierToElementMap[l_sIFrameIdentifier];
    	
    	if (typeof l_oIFrameElement != "undefined")
    	{
			document.getElementById("iframeloader").removeChild(l_oIFrameElement);
    	}

    	l_oIFrameElement = document.createElement('iframe');
		l_oIFrameElement.src = SL_KA;
		l_oIFrameElement.style.display ="none";
		
		l_oIFrameIdentifierToElementMap[l_sIFrameIdentifier] = l_oIFrameElement;
		document.getElementById("iframeloader").appendChild(l_oIFrameElement);
		
		var self = this;
		var SL_N = setTimeout(function(){self.checkLoaded(l_sIFrameIdentifier, SL_F)}, SL_D);

		l_oIFrameIdentifierToTimeoutMap[l_sIFrameIdentifier] = SL_N;
	};
	
	this.checkLoaded = function(l_sIFrameIdentifier, SL_F)
	{
		var SL_N = l_oIFrameIdentifierToTimeoutMap[l_sIFrameIdentifier];
    	if (typeof SL_N != "undefined")
    	{
    		this.clearIFrame(l_sIFrameIdentifier);
    		SL_F.scriptLoadTimeout(l_sIFrameIdentifier);
    	}
	}

	this.iframeLoaded = function(l_sIFrameIdentifier)
	{
		var SL_N = l_oIFrameIdentifierToTimeoutMap[l_sIFrameIdentifier];
    	if (typeof SL_N != "undefined")
    	{
    		clearTimeout(SL_N);
    		this.clearIFrame(l_sIFrameIdentifier);
    	}
	}
	
	this.clearIFrame = function(l_sIFrameIdentifier)
	{
		var l_oIFrameElement = l_oIFrameIdentifierToElementMap[l_sIFrameIdentifier];
    	
    	if (typeof l_oIFrameElement != "undefined")
    	{
			document.getElementById("iframeloader").removeChild(l_oIFrameElement);
    	}
		
 		delete(l_oIFrameIdentifierToElementMap[l_sIFrameIdentifier]);
 		delete(l_oIFrameIdentifierToTimeoutMap[l_sIFrameIdentifier]);
	}
	
};



function SL4B_KeyMasterCredentialsProvider()
{
	
	this.SL_SC = SL4B_Accessor.getConfiguration().getKeyMasterUrl();

	
	this.SL_Re = "default";
	this.SL_Rf = "";
	this.SL_fw = null;
	this.SL_SG = 0;
	
	this.SL_Rt = null;
	
	if (this.SL_SC == null)
	{
				SL4B_Logger.log(SL4B_DebugLevel.const_ERROR_INT, "KeyMasterCredentialsProvider.getCredentials: KeyMaster URL has not been defined");
	}
}

SL4B_KeyMasterCredentialsProvider.prototype = new SL4B_AbstractCredentialsProvider;
SL4B_KeyMasterCredentialsProvider.prototype.getCredentials = LF_KeyMasterCredentialsProvider_GetCredentials;
SL4B_KeyMasterCredentialsProvider.prototype.getKeyMasterToken = LF_KeyMasterCredentialsProvider_GetKeyMasterToken;
SL4B_KeyMasterCredentialsProvider.prototype.getUsername = LF_KeyMasterCredentialsProvider_GetUsername;

SL4B_KeyMasterCredentialsProvider.prototype.scriptLoadSuccess = function(SL_Ey, SL_ALx, SL_Bp)
{
	C_DynamicIFrameLoader.iframeLoaded("keymaster");
	
	this.SL_Rf = SL_ALx;
	this.SL_Rt = SL_Bp;
	C_CallbackQueue.addCallback(new Array(this.SL_fw, "notifyConnectionListeners", this.SL_fw.const_INFO_CONNECTION_EVENT, "KeyMaster authentication success"));

	this.SL_fw.login(this.SL_Rf, SL_Bp);
	
		var l_nKeepAliveInterval = SL4B_Accessor.getConfiguration().getKeyMasterKeepAliveInterval();
	if (l_nKeepAliveInterval > 0)
	{
		var self = this;
		this.SL_SG = setInterval(function(){self.sendKeepAlive()}, l_nKeepAliveInterval);
	}
};

SL4B_KeyMasterCredentialsProvider.prototype.scriptLoadFailure = function(SL_Ey, l_sErrorMsg)
{
	C_DynamicIFrameLoader.iframeLoaded("keymaster");
	
	this.SL_Rt = null;
		
		this.SL_fw.stop();

			C_CallbackQueue.addCallback(new Array(this.SL_fw, "notifyConnectionListeners", this.SL_fw.const_LOGIN_ERROR_CONNECTION_EVENT, "KeyMaster error - " + l_sErrorMsg));
	SL4B_Logger.log(SL4B_DebugLevel.const_ERROR_INT, "KeyMasterCredentialsProvider.scriptLoadFailure: Error: " + l_sErrorMsg);
};

SL4B_KeyMasterCredentialsProvider.prototype.scriptLoadTimeout = function(SL_E)
{
	if (SL_E == "keymaster")
	{
		this.SL_Rt = null;
	
				this.SL_fw.stop();
	
				C_CallbackQueue.addCallback(new Array(this.SL_fw, "notifyConnectionListeners", this.SL_fw.const_LOGIN_ERROR_CONNECTION_EVENT, "KeyMaster error - Could not load keymaster script"));
		SL4B_Logger.log(SL4B_DebugLevel.const_ERROR_INT, "KeyMasterCredentialsProvider.scriptLoadTimeout: Could not load keymaster script");
	}
	else if (SL_E == "keymaster-poll")
	{
		SL4B_Logger.log(SL4B_DebugLevel.const_INFO_INT, "KeyMasterCredentialsProvider.scriptLoadTimeout: Keep-alive polling failed");
	}
	
};

SL4B_KeyMasterCredentialsProvider.prototype.sendKeepAlive = function()
{
	var SL_KA = "";
	var SL_AKf = this.SL_SC.match(/((^|\/)servlet\/)/);
	if (SL_AKf != null)
	{
		SL_KA = this.SL_SC.replace(/((^|\/)servlet\/.*)/, SL_AKf[2] + "poll.jsp");
	}
	else
	{
		SL_KA = this.SL_SC.replace(/[^/]+$/,"poll.jsp");
	}
	
	C_DynamicIFrameLoader.loadIFrame("keymaster-poll",SL_KA, this, SL4B_Accessor.getConfiguration().getKeyMasterConnectionTimeout()); 
};



SL4B_KeyMasterCredentialsProvider.prototype.escapeParameter = function(SL_ALa) {
	return escape(SL_ALa).replace(/[.]/g, "%2E").replace(/@/g, "%40");
};


function LF_KeyMasterCredentialsProvider_GetCredentials(SL_Ar)
{
	this.SL_fw = SL_Ar;
	clearInterval(this.SL_SG);
	
	if (this.SL_SC == null)
	{
		this.sendErrorResponse(SL_Ar, "KeyMaster URL has not been defined");
	}
	else
	{
		this.SL_Rf = "";
		
				var l_sSeparator = ((this.SL_SC.indexOf("?") != -1)?"&":"?");
		var SL_KA = this.SL_SC + l_sSeparator + "type=html&sourceid=" + this.escapeParameter(this.SL_Re) + "&username=" + this.escapeParameter(SL4B_Accessor.getConfiguration().getUsername());
		
						SL4B_Logger.log(SL4B_DebugLevel.const_INFO_INT, "KeyMasterCredentialsProvider.getCredentials: requesting credentials from {0}", SL_KA);

		C_DynamicIFrameLoader.loadIFrame("keymaster", SL_KA, this, SL4B_Accessor.getConfiguration().getKeyMasterConnectionTimeout());
	}
}


function LF_KeyMasterCredentialsProvider_GetKeyMasterToken()
{
	return this.SL_Rt;
}


function LF_KeyMasterCredentialsProvider_GetUsername()
{
	return this.SL_Rf;
}


SL4B_KeyMasterCredentialsProvider.prototype.sendErrorResponse = function(SL_Ar, l_sErrorMessage) {
		SL_Ar.stop();

			C_CallbackQueue.addCallback(new Array(SL_Ar, "notifyConnectionListeners", SL_Ar.const_LOGIN_ERROR_CONNECTION_EVENT, "KeyMaster error - " + l_sErrorMessage));
};




function SigGen_Signature(SL_Ey, SL_ALx, SL_Bp)
{
	try
	{
		SL4B_Accessor.getCredentialsProvider().scriptLoadSuccess(SL_Ey, SL_ALx, SL_Bp);
	}
	catch (e)
	{
		SL4B_Logger.log(SL4B_DebugLevel.const_ERROR_INT, "SigGen_Signature: failed to retrieve SL4B_CredentialsProvider");
		SL4B_Accessor.getExceptionHandler().processException(e);
	}
}


function SigGen_AuthenticationFailed(SL_Ey, l_sErrorMsg)
{
	try
	{
				SL4B_Accessor.getCredentialsProvider().scriptLoadFailure(SL_Ey, l_sErrorMsg);
	}
	catch (e)
	{
		SL4B_Logger.log(SL4B_DebugLevel.const_ERROR_INT, "SigGen_AuthenticationFailed: failed to retrieve SL4B_CredentialsProvider");
		SL4B_Accessor.getExceptionHandler().processException(e);
	}
}

function SigGen_KeepAliveLoaded()
{
	C_DynamicIFrameLoader.iframeLoaded("keymaster-poll");
}



function sl4b_keymaster_credentials_provider_scriptLoaded()
{
		SL4B_Accessor.setCredentialsProvider(new SL4B_KeyMasterCredentialsProvider());
}


function SL4B_LiberatorConfiguration()
{
	
	this.SL_Sd = -1;

	
	this.SL_ST = -1;

	
	this.SL_SU = -1;

	
	this.SL_TC = new Array();
}


SL4B_LiberatorConfiguration.prototype.initialise = function() {
	this.SL_Sd = -1;
	this.SL_ST = -1;
	this.SL_SU = -1;
	this.SL_TC = new Array();
};


SL4B_LiberatorConfiguration.prototype.addConnection = function(l_oConnectionData) {
	this.SL_TC.push(l_oConnectionData);
};


SL4B_LiberatorConfiguration.prototype.getNextConnection = function() {
	var l_oConfigurationData = null;
	if (this.SL_ST != -1)
	{
		l_oConfigurationData = this.SL_TC[this.SL_ST];
		this.SL_SU = this.SL_ST;
		this.SL_ST = -1;
		this.SL_Sd = -1;
	}
	else
	{
		++this.SL_Sd;
		if (this.SL_Sd == this.SL_SU)
		{
						++this.SL_Sd;
		}
		if (this.SL_Sd < this.SL_TC.length)
		{
			l_oConfigurationData = this.SL_TC[this.SL_Sd];
		}
	}
	return l_oConfigurationData;
};


SL4B_LiberatorConfiguration.prototype.peekAtNextConnection = function() {
	var l_oConfigurationData = null;
	if (this.SL_ST != -1)
	{
		l_oConfigurationData = this.SL_TC[this.SL_ST];
	}
	else
	{
		var l_nCurrentConnection = this.SL_Sd + 1;
		if (l_nCurrentConnection == this.SL_SU)
		{
						++l_nCurrentConnection;
		}
		if (l_nCurrentConnection < this.SL_TC.length)
		{
			l_oConfigurationData = this.SL_TC[l_nCurrentConnection];
		}
	}
	return l_oConfigurationData;
};


SL4B_LiberatorConfiguration.prototype.resetConnections = function() {
	this.SL_Sd = -1;
	this.SL_ST = -1;
	this.SL_SU = -1;
};


SL4B_LiberatorConfiguration.prototype.connectionOk = function() {
	this.SL_ST = this.SL_Sd;
};

SL4B_LiberatorConfiguration.prototype.toString = function()
{
	var SL_ALa = "LiberatorConfiguration:\n";
	for (var SL_Kn=0; SL_Kn <this.SL_TC.length; SL_Kn++)
	{
		var l_oConnectionData = this.SL_TC[SL_Kn];
		SL_ALa += l_oConnectionData.toString() + "\n";
	}
	return SL_ALa;
};

SL4B_LiberatorConfiguration.prototype.toSimpleString = function()
{
	var SL_ALa = "";
	for (var SL_Kn=0; SL_Kn <this.SL_TC.length; SL_Kn++)
	{
		var l_oConnectionData = this.SL_TC[SL_Kn];
		SL_ALa +=  l_oConnectionData.SL_Wh + " ";
		SL_ALa +=  l_oConnectionData.SL_WW + " ";
		SL_ALa +=  l_oConnectionData.SL_TT + " ";
		SL_ALa +=  l_oConnectionData.SL_WF  + ", ";
	}
	return SL_ALa;
};


function SL4B_SimpleLiberatorConfiguration()
{
	this.initialise();

		var SL_Jm = SL4B_Accessor.getConfiguration();

		var l_sServerUrl = SL_Jm.getServerUrl();
	var l_sProtocol = null;
	var l_sAddress = null;
	var l_sPort = null;
	if (l_sServerUrl.match(/^http/))
	{
		l_sProtocol = l_sServerUrl.match(/^(https?)/)[1];
		l_sAddress = l_sServerUrl.match(/^https?:\/\/([^:\/]+)/)[1];

				var SL_AKf = l_sServerUrl.match(/:(\d+)/);
		l_sPort = ((SL_AKf == null)?null:SL_AKf[1]);
	}

	var l_pTypes = SL_Jm.getConnectionTypes();

		for (var SL_HI = 0, SL_AJl = l_pTypes.length; SL_HI < SL_AJl; ++SL_HI)
	{
		this.addConnection(new SL4B_ConnectionData(l_sProtocol, l_sAddress, l_sPort, parseInt(l_pTypes[SL_HI], 10)));
	}
}

SL4B_SimpleLiberatorConfiguration.prototype = new SL4B_LiberatorConfiguration;




function SL4B_ConnectionData(l_sProtocol, l_sAddress, l_sPort, SL_HI)
{
	
	this.SL_Wh = l_sProtocol;

	
	this.SL_WW = l_sAddress;

	
	this.SL_TT = l_sPort;

	
	this.SL_WF = SL_HI;

	
	this.getProtocol = function() {
		return this.SL_Wh;
	};

	
	this.getAddress = function() {
		return this.SL_WW;
	};

	
	this.getPort = function() {
		return this.SL_TT;
	};

	
	this.getType = function() {
		return this.SL_WF;
	};

	
	this.toString = function() {
		var SL_ALa = "ConnectionData(";
		SL_ALa += "Protocol = " + this.SL_Wh + ", ";
		SL_ALa += "Address = " + this.SL_WW + ", ";
		SL_ALa += "Port = " + this.SL_TT + ", ";
		SL_ALa += "Type = " + this.SL_WF  + ")";
		return SL_ALa;
	};
}


SL4B_ConnectionData.prototype.getServerUrl = function() {
	var l_sServerUrl = "";
	if (this.SL_Wh != null)
	{
		l_sServerUrl = this.SL_Wh + "://" + this.SL_WW + ((this.SL_TT != null)?":" + this.SL_TT:"");
	}
	else
	{
		l_sServerUrl = SL4B_Accessor.getConfiguration().getServerUrl().replace(/\/$/, "");
	}
	return l_sServerUrl;
};



function GF_RttpCommandQueue()
{
	
	this.SL_TX = new Array();
}

GF_RttpCommandQueue.prototype.sendNext = GF_RttpCommandQueue_SendNext;
GF_RttpCommandQueue.prototype.queueCommand = GF_RttpCommandQueue_QueueCommand;
GF_RttpCommandQueue.prototype.checkArguments = GF_RttpCommandQueue_CheckArguments;


GF_RttpCommandQueue.prototype.isEmpty = function() { return (this.SL_TX.length == 0); };

GF_RttpCommandQueue.prototype.getObject = function(SL_DD, SL_AMa, SL_CC) { this.queueCommand(LF_RttpCommandTypes.const_GET_OBJECT, SL_DD, SL_AMa, SL_CC); };
GF_RttpCommandQueue.prototype.getObjects = function(SL_DD, SL_DU, SL_CC) { this.queueCommand(LF_RttpCommandTypes.const_GET_OBJECTS, SL_DD, SL_DU, SL_CC); };
GF_RttpCommandQueue.prototype.removeObject = function(SL_DD, SL_AMa, SL_CC) { this.queueCommand(LF_RttpCommandTypes.const_REMOVE_OBJECT, SL_DD, SL_AMa, SL_CC); };
GF_RttpCommandQueue.prototype.removeObjects = function(SL_DD, SL_DU, SL_CC) { this.queueCommand(LF_RttpCommandTypes.const_REMOVE_OBJECTS, SL_DD, SL_DU, SL_CC); };
GF_RttpCommandQueue.prototype.getObjectType = function(SL_DD, SL_AMa) { this.queueCommand(LF_RttpCommandTypes.const_GET_OBJECT_TYPE, SL_DD, SL_AMa); };
GF_RttpCommandQueue.prototype.setThrottleObject = function(SL_AMa, SL_DM) { this.queueCommand(LF_RttpCommandTypes.const_SET_THROTTLE_OBJECT, SL_AMa, SL_DM); };
GF_RttpCommandQueue.prototype.setThrottleObjects = function(SL_DU, SL_DM) { this.queueCommand(LF_RttpCommandTypes.const_SET_THROTTLE_OBJECTS, SL_DU, SL_DM); };
GF_RttpCommandQueue.prototype.setGlobalThrottle = function(SL_DM) { this.queueCommand(LF_RttpCommandTypes.const_SET_GLOBAL_THROTTLE, SL_DM); };
GF_RttpCommandQueue.prototype.disableWTStatsTimeout = function(SL_Dx) { this.queueCommand(LF_RttpCommandTypes.const_DISABLE_WTSTATS_TIMEOUT, SL_Dx); };
GF_RttpCommandQueue.prototype.clearObjectListeners = function(SL_DD, SL_DS) { this.queueCommand(LF_RttpCommandTypes.const_CLEAR_OBJECT_LISTENERS, SL_DD, SL_DS); };
GF_RttpCommandQueue.prototype.blockObjectListeners = function(SL_DD, SL_DU) { this.queueCommand(LF_RttpCommandTypes.const_BLOCK_OBJECT_LISTENERS, SL_DD, SL_DU); };
GF_RttpCommandQueue.prototype.unblockObjectListeners = function(SL_DD, SL_DU) { this.queueCommand(LF_RttpCommandTypes.const_UNBLOCK_OBJECT_LISTENERS, SL_DD, SL_DU); };
GF_RttpCommandQueue.prototype.createObject = function(SL_AMa, SL_DY) { this.queueCommand(LF_RttpCommandTypes.const_CREATE_OBJECT, SL_AMa, SL_DY); };
GF_RttpCommandQueue.prototype.contribObject = function(SL_DD, SL_AMa, SL_FX) { this.queueCommand(LF_RttpCommandTypes.const_CONTRIB_OBJECT, SL_DD, SL_AMa, SL_FX); };
GF_RttpCommandQueue.prototype.deleteObject = function(SL_AMa) { this.queueCommand(LF_RttpCommandTypes.const_DELETE_OBJECT, SL_AMa); };
GF_RttpCommandQueue.prototype.getFieldNames = function() { this.queueCommand(LF_RttpCommandTypes.const_GET_FIELD_NAMES); };
GF_RttpCommandQueue.prototype.logout = function() { this.queueCommand(LF_RttpCommandTypes.const_LOGOUT); };
GF_RttpCommandQueue.prototype.debug = function(SL_Df, SL_EE) { this.queueCommand(LF_RttpCommandTypes.const_DEBUG, SL_Df, SL_EE); };
GF_RttpCommandQueue.prototype.setDebugLevel = function(SL_Df) { this.queueCommand(LF_RttpCommandTypes.const_SET_DEBUG_LEVEL, SL_Df); };
GF_RttpCommandQueue.prototype.getVersion = function() { this.queueCommand(LF_RttpCommandTypes.const_GET_VERSION); };
GF_RttpCommandQueue.prototype.getVersionInfo = function() { this.queueCommand(LF_RttpCommandTypes.const_GET_VERSION_INFO); };
GF_RttpCommandQueue.prototype.addConnectionListener = function(SL_Dp) { this.queueCommand(LF_RttpCommandTypes.const_ADD_CONNECTION_LISTENER, SL_Dp); };
GF_RttpCommandQueue.prototype.removeConnectionListener = function(SL_Dp) { this.queueCommand(LF_RttpCommandTypes.const_REMOVE_CONNECTION_LISTENER, SL_Dp); };
GF_RttpCommandQueue.prototype.getContainer = function(SL_DD, SL_JK, SL_CC) { this.queueCommand(LF_RttpCommandTypes.const_GET_CONTAINER, SL_DD, SL_JK, SL_CC); };
GF_RttpCommandQueue.prototype.removeContainer = function(SL_DD, SL_JK, SL_CC) { this.queueCommand(LF_RttpCommandTypes.const_REMOVE_CONTAINER, SL_DD, SL_JK, SL_CC); };
GF_RttpCommandQueue.prototype.removeSubscriber = function(SL_DD) { this.queueCommand(LF_RttpCommandTypes.const_REMOVE_SUBSCRIBER, SL_DD); };


function GF_RttpCommandQueue_SendNext(SL_Ar)
{
	var l_oNextCommand = this.SL_TX.shift();
   var l_nCommandType = l_oNextCommand.SL_Ta;
   var SL_Ke = l_oNextCommand.SL_Te;

   switch (l_nCommandType)
   {
   case LF_RttpCommandTypes.const_GET_OBJECT:
      if (this.checkArguments(SL_Ke, 3))
      {
         SL_Ar.getObject(SL_Ke[1], SL_Ke[2], SL_Ke[3]);
      }
      break;
   case LF_RttpCommandTypes.const_GET_OBJECTS:
      if (this.checkArguments(SL_Ke, 3))
      {
         SL_Ar.getObjects(SL_Ke[1], SL_Ke[2], SL_Ke[3]);
      }
      break;
   case LF_RttpCommandTypes.const_REMOVE_OBJECT:
      if (this.checkArguments(SL_Ke, 3))
      {
         SL_Ar.removeObject(SL_Ke[1], SL_Ke[2], SL_Ke[3]);
      }
      break;
   case LF_RttpCommandTypes.const_GET_OBJECT_TYPE:
      if (this.checkArguments(SL_Ke, 2))
      {
         SL_Ar.getObjectType(SL_Ke[1], SL_Ke[2]);
      }
      break;
   case LF_RttpCommandTypes.const_SET_THROTTLE_OBJECT:
      if (this.checkArguments(SL_Ke, 2))
      {
         SL_Ar.setThrottleObject(SL_Ke[1], SL_Ke[2]);
      }
      break;
   case LF_RttpCommandTypes.const_SET_THROTTLE_OBJECTS:
      if (this.checkArguments(SL_Ke, 2))
      {
         SL_Ar.setThrottleObjects(SL_Ke[1], SL_Ke[2]);
      }
      break;
   case LF_RttpCommandTypes.const_SET_GLOBAL_THROTTLE:
      if (this.checkArguments(SL_Ke, 1))
      {
         SL_Ar.setGlobalThrottle(SL_Ke[1]);
      }
      break;
   case LF_RttpCommandTypes.const_DISABLE_WTSTATS_TIMEOUT:
      if (this.checkArguments(SL_Ke, 1))
      {
         SL_Ar.disableWTStatsTimeout(SL_Ke[1]);
      }
      break;
   case LF_RttpCommandTypes.const_CLEAR_OBJECT_LISTENERS:
      if (this.checkArguments(SL_Ke, 2))
      {
         SL_Ar.clearObjectListeners(SL_Ke[1], SL_Ke[2]);
      }
      break;
   case LF_RttpCommandTypes.const_BLOCK_OBJECT_LISTENERS:
      if (this.checkArguments(SL_Ke, 2))
      {
         SL_Ar.blockObjectListeners(SL_Ke[1], SL_Ke[2]);
      }
      break;
   case LF_RttpCommandTypes.const_UNBLOCK_OBJECT_LISTENERS:
      if (this.checkArguments(SL_Ke, 2))
      {
         SL_Ar.unblockObjectListeners(SL_Ke[1], SL_Ke[2]);
      }
      break;
   case LF_RttpCommandTypes.const_CREATE_OBJECT:
      if (this.checkArguments(SL_Ke, 2))
      {
         SL_Ar.createObject(SL_Ke[1], SL_Ke[2]);
      }
      break;
   case LF_RttpCommandTypes.const_CONTRIB_OBJECT:
      if (this.checkArguments(SL_Ke, 3))
      {
         SL_Ar.contribObject(SL_Ke[1], SL_Ke[2], SL_Ke[3]);
      }
      break;
   case LF_RttpCommandTypes.const_DELETE_OBJECT:
      if (this.checkArguments(SL_Ke, 1))
      {
         SL_Ar.deleteObject(SL_Ke[1]);
      }
      break;
   case LF_RttpCommandTypes.const_GET_FIELD_NAMES:
      if (this.checkArguments(SL_Ke, 0))
      {
         SL_Ar.getFieldNames();
      }
      break;
   case LF_RttpCommandTypes.const_LOGOUT:
      if (this.checkArguments(SL_Ke, 0))
      {
         SL_Ar.logout();
      }
      break;
   case LF_RttpCommandTypes.const_DEBUG:
      if (this.checkArguments(SL_Ke, 0))
      {
         SL_Ar.debug();
      }
      break;
   case LF_RttpCommandTypes.const_SET_DEBUG_LEVEL:
      if (this.checkArguments(SL_Ke, 1))
      {
         SL_Ar.setDebugLevel(SL_Ke[1]);
      }
      break;
   case LF_RttpCommandTypes.const_GET_VERSION:
      if (this.checkArguments(SL_Ke, 0))
      {
         SL_Ar.getVersion();
      }
      break;
   case LF_RttpCommandTypes.const_GET_VERSION_INFO:
      if (this.checkArguments(SL_Ke, 0))
      {
         SL_Ar.getVersionInfo();
      }
      break;
   case LF_RttpCommandTypes.const_ADD_CONNECTION_LISTENER:
      if (this.checkArguments(SL_Ke, 1))
      {
         SL_Ar.addConnectionListener(SL_Ke[1]);
      }
      break;
   case LF_RttpCommandTypes.const_REMOVE_CONNECTION_LISTENER:
      if (this.checkArguments(SL_Ke, 1))
      {
         SL_Ar.removeConnectionListener(SL_Ke[1]);
      }
      break;
   case LF_RttpCommandTypes.const_GET_CONTAINER:
      if (this.checkArguments(SL_Ke, 3))
      {
         SL_Ar.getContainer(SL_Ke[1], SL_Ke[2], SL_Ke[3]);
      }
      break;
   case LF_RttpCommandTypes.const_REMOVE_CONTAINER:
      if (this.checkArguments(SL_Ke, 3))
      {
         SL_Ar.removeContainer(SL_Ke[1], SL_Ke[2], SL_Ke[3]);
      }
      break;
   case LF_RttpCommandTypes.const_REMOVE_SUBSCRIBER:
      if (this.checkArguments(SL_Ke, 1))
      {
         SL_Ar.removeSubscriber(SL_Ke[1]);
      }
      break;
	default:
				SL4B_Logger.log(SL4B_DebugLevel.const_ERROR_INT, "RttpCommandQueue.sendNext: unknown command ({0}) - {1}", l_nCommandType, l_oNextCommand);
      break;
   }
}


function GF_RttpCommandQueue_QueueCommand(l_nCommandType)
{
	this.SL_TX.push(new LF_RttpCommand(l_nCommandType, GF_RttpCommandQueue_QueueCommand.arguments));
}


function GF_RttpCommandQueue_CheckArguments(SL_Ke, l_nMinimumSize)
{
   return SL_Ke.length > l_nMinimumSize;
}




function LF_RttpCommand(l_nCommandType, SL_Ke)
{
   
	this.SL_Ta = l_nCommandType;

	
   this.SL_Te = SL_Ke;
}




LF_RttpCommandTypes = new function()
{
	
	this.const_GET_OBJECT = 1;

	
	this.const_GET_OBJECTS = 2;

	
	this.const_REMOVE_OBJECT = 3;

	
	this.const_REMOVE_OBJECTS = 4;

	
	this.const_GET_OBJECT_TYPE = 5;

	
	this.const_SET_THROTTLE_OBJECT = 6;

	
	this.const_SET_THROTTLE_OBJECTS = 7;

	
	this.const_SET_GLOBAL_THROTTLE = 8;

	
	this.const_DISABLE_WTSTATS_TIMEOUT = 9;

	
	this.const_CLEAR_OBJECT_LISTENERS = 10;

	
	this.const_BLOCK_OBJECT_LISTENERS = 11;

	
	this.const_UNBLOCK_OBJECT_LISTENERS = 12;

	
	this.const_CREATE_OBJECT = 13;

	
	this.const_CONTRIB_OBJECT = 14;

	
	this.const_DELETE_OBJECT = 15;

	
	this.const_GET_FIELD_NAMES = 16;

	
	this.const_LOGOUT = 17;

	
	this.const_DEBUG = 18;

	
	this.const_SET_DEBUG_LEVEL = 19;

	
	this.const_GET_VERSION = 20;

	
	this.const_GET_VERSION_INFO = 21;

	
	this.const_ADD_CONNECTION_LISTENER = 22;

	
	this.const_REMOVE_CONNECTION_LISTENER = 23;

	
	this.const_GET_CONTAINER = 24;

	
	this.const_REMOVE_CONTAINER = 25;

	
	this.const_REMOVE_SUBSCRIBER = 26;
};




function SL4B_SlaveFrameRttpProvider()
{
	
	this.SL_UD = null;

	
		this.SL_Tv = new GF_RttpCommandQueue();

	
	this.SL_Th = false;

}

SL4B_SlaveFrameRttpProvider.prototype = new SL4B_AbstractRttpProvider;

SL4B_SlaveFrameRttpProvider.prototype.register = LF_SlaveFrameRttpProvider_Register;
SL4B_SlaveFrameRttpProvider.prototype.masterRegistered = LF_SlaveFrameRttpProvider_MasterRegistered;
SL4B_SlaveFrameRttpProvider.prototype.masterClosing = LF_SlaveFrameRttpProvider_MasterClosing;


SL4B_SlaveFrameRttpProvider.prototype.connect = function () {  };
SL4B_SlaveFrameRttpProvider.prototype.login = function (SL_ALx, SL_Bp) {  };
SL4B_SlaveFrameRttpProvider.prototype.reconnect = function () {  };
SL4B_SlaveFrameRttpProvider.prototype.getObject = LF_SlaveFrameRttpProvider_GetObject; 
SL4B_SlaveFrameRttpProvider.prototype.getObjects = LF_SlaveFrameRttpProvider_GetObjects;
SL4B_SlaveFrameRttpProvider.prototype.removeObject = LF_SlaveFrameRttpProvider_RemoveObject; 
SL4B_SlaveFrameRttpProvider.prototype.removeObjects = LF_SlaveFrameRttpProvider_RemoveObjects;
SL4B_SlaveFrameRttpProvider.prototype.removeSubscriber = LF_SlaveFrameRttpProvider_RemoveSubscriber; 
SL4B_SlaveFrameRttpProvider.prototype.getObjectType = LF_SlaveFrameRttpProvider_GetObjectType;
SL4B_SlaveFrameRttpProvider.prototype.setThrottleObject = LF_SlaveFrameRttpProvider_SetThrottleObject;
SL4B_SlaveFrameRttpProvider.prototype.setThrottleObjects = LF_SlaveFrameRttpProvider_SetThrottleObjects;
SL4B_SlaveFrameRttpProvider.prototype.setGlobalThrottle = LF_SlaveFrameRttpProvider_SetGlobalThrottle;
SL4B_SlaveFrameRttpProvider.prototype.createObject = LF_SlaveFrameRttpProvider_CreateObject;
SL4B_SlaveFrameRttpProvider.prototype.contribObject = LF_SlaveFrameRttpProvider_ContribObject;
SL4B_SlaveFrameRttpProvider.prototype.deleteObject = LF_SlaveFrameRttpProvider_DeleteObject;
SL4B_SlaveFrameRttpProvider.prototype.getFieldNames = LF_SlaveFrameRttpProvider_GetFieldNames;
SL4B_SlaveFrameRttpProvider.prototype.logout = function() {  };
SL4B_SlaveFrameRttpProvider.prototype.initialise = function() {  };
SL4B_SlaveFrameRttpProvider.prototype.stop = LF_SlaveFrameRttpProvider_Stop;

SL4B_SlaveFrameRttpProvider.prototype.disableWTStatsTimeout = function(SL_Dx) { this.SL_UD.disableWTStatsTimeout(SL_Dx); };
SL4B_SlaveFrameRttpProvider.prototype.clearObjectListeners = function(SL_DD, SL_DS) { this.SL_UD.clearObjectListeners(SL_DD, SL_DS); };
SL4B_SlaveFrameRttpProvider.prototype.blockObjectListeners = function(SL_DD, SL_DU) { this.SL_UD.blockObjectListeners(SL_DD, SL_DU); };
SL4B_SlaveFrameRttpProvider.prototype.unblockObjectListeners = function(SL_DD, SL_DU) { this.SL_UD.unblockObjectListeners(SL_DD, SL_DU); };
SL4B_SlaveFrameRttpProvider.prototype.debug = function(SL_Df, SL_EE) { this.SL_UD.debug(SL_Df, SL_EE); };
SL4B_SlaveFrameRttpProvider.prototype.setDebugLevel = function(SL_Df) { return this.SL_UD.setDebugLevel(SL_Df); };
SL4B_SlaveFrameRttpProvider.prototype.getVersion = function() { return this.SL_UD.getVersion() + "-" + this.SL_UD.getBuildVersion(); };
SL4B_SlaveFrameRttpProvider.prototype.getVersionInfo = function() { return this.SL_UD.getVersionInfo(); };



function LF_SlaveFrameRttpProvider_GetObject(SL_DD, SL_AMa, SL_CC)
{
		if(this.SL_UD != null)
	{
		this.SL_UD.getObject(SL_DD, SL_AMa, SL_CC);
	}
	else
	{
		this.SL_Tv.getObject(SL_DD, SL_AMa, SL_CC);
	}
}

function LF_SlaveFrameRttpProvider_GetObjects(SL_DD, SL_DU, SL_CC)
{
		this.SL_UD.getObjects(SL_DD, SL_DU, SL_CC);
}

function LF_SlaveFrameRttpProvider_RemoveObject(SL_DD, SL_AMa, SL_CC)
{
		this.SL_UD.removeObject(SL_DD, SL_AMa, SL_CC); 
}

function LF_SlaveFrameRttpProvider_RemoveObjects(SL_DD, SL_DU, SL_CC)
{
		this.SL_UD.removeObjects(SL_DD, SL_DU, SL_CC);
}

function LF_SlaveFrameRttpProvider_RemoveSubscriber(SL_DD)
{
			if (this.SL_UD != null)
	{
		this.SL_UD.removeSubscriber(SL_DD);
	}
}

function LF_SlaveFrameRttpProvider_GetObjectType(SL_DD, SL_AMa)
{
	this.SL_UD.getObjectType(SL_DD, SL_AMa);
}

function LF_SlaveFrameRttpProvider_SetThrottleObject(SL_AMa, SL_DM)
{
	this.SL_UD.setThrottleObject(SL_AMa, SL_DM);
}

function LF_SlaveFrameRttpProvider_SetThrottleObjects(SL_DU, SL_DM)
{
	this.SL_UD.setThrottleObject(SL_DU, SL_DM);
}

function LF_SlaveFrameRttpProvider_SetGlobalThrottle(SL_DM)
{
	this.SL_UD.setGlobalThrottle(SL_DM);
}

function LF_SlaveFrameRttpProvider_CreateObject(SL_AMa, SL_DY)
{
	return this.SL_UD.createObject(SL_AMa, SL_DY);
}

function LF_SlaveFrameRttpProvider_ContribObject(SL_DD, SL_AMa, SL_FX)
{
	this.SL_UD.contribObject(SL_DD, SL_AMa, SL_FX);
}

function LF_SlaveFrameRttpProvider_DeleteObject(SL_AMa)
{
	return this.SL_UD.deleteObject(SL_AMa);
}

function LF_SlaveFrameRttpProvider_GetFieldNames()
{
	return this.SL_UD.getFieldNames();
}


function LF_SlaveFrameRttpProvider_Register()
{
	setTimeout("SL4B_FrameRegistrarAccessor.registerSlaveFrame(SL4B_Accessor.getConfiguration().getFrameId(), SL4B_Accessor.getRttpProvider())",0);
}


function LF_SlaveFrameRttpProvider_Stop()
{
		SL4B_FrameRegistrarAccessor.deregisterSlaveFrame(SL4B_Accessor.getConfiguration().getFrameId());

			if(this.SL_UD != null)
	{
		this.SL_UD.deregisterSlave(SL4B_Accessor.getConfiguration().getFrameId(), this, SL4B_SubscriptionManager);
	}
	
	for(var i = 0; i < SL4B_SubscriptionManager.SL_Oq.length; i++) {
		this.removeSubscriber(SL4B_SubscriptionManager.SL_Oq[i]);
	}
}


function LF_SlaveFrameRttpProvider_MasterRegistered(SL_Be)
{
	SL4B_Logger.log(SL4B_DebugLevel.const_RTTP_FINEST_INT, "SlaveFrameRttpProvider.masterRegistered: {0}", SL_Be);
	this.SL_UD = SL_Be;
	
		SL_Be.registerSlave(SL4B_Accessor.getConfiguration().getFrameId(), this, SL4B_SubscriptionManager);

	if (this.SL_Th == true)
	{
		window.location.replace(window.location.href);

					}
}


function LF_SlaveFrameRttpProvider_MasterClosing()
{
	SL4B_Logger.log(SL4B_DebugLevel.const_RTTP_FINEST_INT, "SlaveFrameRttpProvider.masterClosing");

	this.SL_UD = null;
	this.SL_Th = true;
}

function SL4B_MultiSourceRttpProvider()
{
	}


 

function SL4B_FailoverAlgorithm()
{
	
	this.nextLiberatorConfiguration = function(){};

	
	this.setConnected = function(){};
}




function SL4B_ZunAlgorithm()
{
	this.initialise = function(SL_KA)
	{
		
		this.SL_Uh =  new SL4B_FailoverConfiguration();
		this.SL_Uh.load(SL_KA);

		
		this.SL_VE = null;

		
		this.SL_Uf = null;

		
		this.SL_VF = true;

		
		this.SL_Ux = true;

		
		this.SL_UY = this.SL_Uh.getAlgorithm();
	};

	
	this.setAlgorithm = function(l_sAlgorithm)
	{
		this.SL_UY = l_sAlgorithm;
	};

	
	this.setServerWeights= function(l_pServers)
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.setServerWeights");
		var l_nWeight = 0;
		for (var i = 0; i<l_pServers.length; i++)
		{
			var l_oServer = l_pServers[i];
			if (!l_oServer.isTried())
			{
				l_oServer.setWeightStart(l_nWeight);
				l_nWeight += l_oServer.getWeight();
				l_oServer.setWeightEnd(l_nWeight);
			}
		}
		return l_nWeight;
	};

	
	this.clearTries= function(l_pServers, l_oExcludeServer)
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.clearTries");
		for (var i = 0; i<l_pServers.length; i++)
		{
			var l_oServer = l_pServers[i];
			if (l_oServer == l_oExcludeServer)
			{
				l_oServer.setTried(true);
			}
			else
			{
				l_oServer.setTried(false);
			}
		}
	};

	
	this.chooseRandomServer= function(l_pServers)
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.chooseRandomServer");
		var l_nWeightMax = this.setServerWeights(l_pServers);
		var l_nRandom = this.random(l_nWeightMax);
		for (var i = 0; i<l_pServers.length; i++)
		{
			var l_oServer = l_pServers[i];
			if (!l_oServer.isTried())
			{
				SL4B_Failover_Log("\t" + l_oServer.getAddress() + " " + l_oServer.getWeightStart() + " " + l_oServer.getWeightEnd() + " " + l_nRandom);
				if (l_oServer.getWeightStart() <= l_nRandom && l_nRandom < l_oServer.getWeightEnd() )
				{
					SL4B_Failover_Log("\t\tchosen");
					return l_oServer;
				}
			}
		}
		return null;
	};

	
	this.random= function(l_nMax)
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.random");
		return SL_BL = Math.random()*100000%l_nMax;
	};

	
	this.chooseRandomPrimaryServer= function()
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.chooseRandomPrimaryServer");
		return this.chooseRandomServer(this.SL_Uh.getPrimaryServers());
	};

	
	this.chooseRandomBackupServer= function()
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.chooseRandomBackupServer");
		return this.chooseRandomServer(this.SL_Uh.getBackupServers());
	};

	
	this.nextLiberatorConfiguration = function()
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.nextServer");
		if (this.SL_VF == true)
		{
						if (this.SL_VE != this.SL_Uf)
			{
				this.SL_VE = null;
			}
			
			this.clearTries(this.SL_Uh.getPrimaryServers(), this.SL_VE);
			this.clearTries(this.SL_Uh.getBackupServers(), this.SL_VE);
			this.SL_VF = false;
			this.SL_Ux = true;
			this.SL_Uf = null;
		}
		
		var l_oServer = null;
		var SL_Al = null;
		
		switch (this.SL_UY)
		{
			case "Z":
				l_oServer = this.nextZServer();
				break;
			case "U":
				l_oServer = this.nextUServer();
				break;
			case "N":
				l_oServer = this.nextNServer();
				break;
		}
		
		if (l_oServer != null)
		{
			l_oServer.setTried(true);
			this.SL_VE = l_oServer;
			
						SL_Al = new SL4B_LiberatorConfiguration();
			SL_Al.initialise();
			
			var l_pConnections = l_oServer.getConnections();
			for (var SL_Kn = 0; SL_Kn < l_pConnections.length; SL_Kn++)
			{
				var failoverServerConnection = l_pConnections[SL_Kn];

				var l_sProtocol = failoverServerConnection.getProtocol();
				var l_sPort = l_oServer.getPorts()[l_sProtocol];
				if (l_sPort == null)
				{
					l_sPort = ((l_sProtocol == "http")?"80":"443");
				}
				var l_oConnection = new SL4B_ConnectionData(l_sProtocol, l_oServer.getAddress(), l_sPort, failoverServerConnection.getType());
				SL_Al.addConnection(l_oConnection);
			}
		}
		else
		{
			this.SL_VF = true;
		}
	
		return SL_Al;
	};
	
	
	this.nextZServer= function()
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.nextZServer");
		var l_oServer = null;

				l_oServer = this.chooseRandomPrimaryServer();
		if (l_oServer != null)
		{
		 	return l_oServer;
		}

				l_oServer = this.chooseRandomBackupServer();
		if (l_oServer != null)
		{
		 	return l_oServer;
		}

		return null;
	};

	
	this.nextUServer= function()
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.nextUServer");
		var l_oServer = null;
				if (this.SL_Ux == true)
		{
		 	this.SL_Ux = false; 
			l_oServer = this.chooseRandomPrimaryServer();
			if (l_oServer != null)
			{
			 	return l_oServer;
			}
		}

				if (!this.SL_VE.isBackup()) 		{
			l_oServer = this.SL_VE.getPairedServer();
			if (l_oServer != null && l_oServer.isTried() == false)
			{
			 	return l_oServer;
			}
		}
		
				l_oServer = this.chooseRandomBackupServer();
		if (l_oServer != null)
		{
		 	return l_oServer;
		}

	   		l_oServer = this.chooseRandomPrimaryServer();
		if (l_oServer != null)
		{
		 	return l_oServer;
		}

		return null;
	};

	
	this.nextNServer= function()
	{
		SL4B_Failover_Log("SL4B_ZunAlgorithm.nextUServer");
		var l_oServer = null;
		
				if (this.SL_Ux == true)
		{
		 	this.SL_Ux = false; 
			l_oServer = this.chooseRandomPrimaryServer();
			if (l_oServer != null)
			{
			 	return l_oServer;
			}
		}

				if (this.SL_VE != null && !this.SL_VE.isBackup()) 		{
			l_oServer = this.SL_VE.getPairedServer();
			if (l_oServer != null)
			{
			 	return l_oServer;
			}
		}

				l_oServer = this.chooseRandomPrimaryServer();
		if (l_oServer != null)
		{
		 	return l_oServer;
		}

				l_oServer = this.chooseRandomBackupServer();
		if (l_oServer != null)
		{
		 	return l_oServer;
		}

		return null;
	};
	
	
	this.setConnected = function()
	{
		this.SL_Uf = this.SL_VE;
		this.SL_VF = true;
	};
}


function sl4b_failover_zun_algorithm_scriptLoaded()
{
	SL4B_ZunAlgorithm.prototype = new SL4B_FailoverAlgorithm;
}





function SL4B_Failover_Log(SL_EE)
{
	} 
 
 

function SL4B_FailoverConfiguration()
{
	
	this.SL_ve = "";

	
	this.SL_VV = "Z";

	
	this.SL_VW = new Array();

	
	this.SL_VY = new Array();


	
	
	this.getName = function()
	{
		return this.SL_ve;
	};
	
	this.getAlgorithm = function()
	{
		return this.SL_VV;
	};
	
	this.getPrimaryServers = function()
	{
		return this.SL_VW;
	};
	
	this.getBackupServers = function()
	{
		return this.SL_VY;
	};


	
	this.load = function(SL_KA)
	{
		SL_AKZ = null;
		try
		{
						if (typeof XMLHttpRequest != 'undefined')
			{
				SL_AKZ = new XMLHttpRequest();
			}
			else
			{
				try
				{
					SL_AKZ = new ActiveXObject("Msxml2.XMLHTTP");
				}
				catch (e)
				{
					SL_AKZ = new ActiveXObject("Microsoft.XMLHTTP");
				}
			}
						SL_AKZ.open("GET", SL_KA, false);
			SL_AKZ.send(null);
			
			if (SL_AKZ.status == 200) 
			{
				SL4B_Failover_Log("SL4B_FailoverConfiguration: Loaded file " + SL_KA + ", status=" + SL_AKZ.status+ " message: " + SL_AKZ.statusText);
				
				var l_oDocElement = SL4B_XmlResponseRetriever.getXmlDocumentElement(SL_AKZ);
				if (l_oDocElement == null)
				{
        			SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, "Error parsing XML configuration (" + SL_KA + "): " + e.toString());
        			SL4B_Failover_Log("SL4B_FailoverConfiguration: Error parsing XML configuration (" + SL_KA + "): " +  +  e.message);
				   throw e;
				}
				this.parseRttpService(l_oDocElement);
				SL4B_Failover_Log(this.toString());
			}
			else
			{
				SL4B_Failover_Log("SL4B_FailoverConfiguration: Failed to load file " + SL_KA + ", status=" + SL_AKZ.status+ " message: " + SL_AKZ.statusText);
				throw "SL4B_FailoverConfiguration: Failed to load file " + SL_KA + ", status=" + SL_AKZ.status+ " message: " + SL_AKZ.statusText;
			}
		}
		catch (e)
		{
			SL4B_Logger.log(SL4B_DebugLevel.const_WARN_INT, e.toString());
			SL4B_Failover_Log("SL4B_FailoverConfiguration: Exception: " +  e.message);
			throw (e);
		}
	};

	
	this.parseRttpService = function(SL_BU)
	{
		SL4B_Failover_Log("\tparseRttpService " + SL_BU.tagName);
		try
		{
			var l_pChildren = SL_BU.childNodes;
			for (var i=0; i< l_pChildren.length; i++)
			{
				l_oChild = l_pChildren[i];
				if (l_oChild.tagName == "name")
				{
					this.SL_ve = l_oChild.firstChild.nodeValue;
				}
				else if (l_oChild.tagName == "failoveralgorithm")
				{
					this.SL_VV = l_oChild.firstChild.nodeValue;
				}
				else if (l_oChild.tagName == "rttpsite")
				{
					this.parseRttpSite(l_oChild);
				}
			}
		}
		catch (e)
		{
			SL4B_Failover_Log("SL4B_FailoverConfiguration: Failed to parse rttpservice");
			throw (e);
		}
	};

	
	this.parseRttpSite = function(SL_BU)
	{
		SL4B_Failover_Log("\tparseRttpSite " + SL_BU.tagName);
		try
		{
			var l_pChildren = SL_BU.childNodes;
			for (var i=0; i< l_pChildren.length; i++)
			{
				l_oChild = l_pChildren[i];
				if (l_oChild.tagName == "serverpair")
				{
					this.parseServerPair(l_oChild);
				}
				else if (l_oChild.tagName == "primaryserver")
				{
					var l_oServer = new SL4B_FailoverServer();
					l_oServer.parseServer(l_oChild);
					this.SL_VW.push(l_oServer);
				}
				else if (l_oChild.tagName == "backupserver")
				{
					var l_oServer = new SL4B_FailoverServer();
					l_oServer.parseServer(l_oChild);
					this.SL_VY.push(l_oServer);
				}
			}
		}
		catch (e)
		{
			SL4B_Failover_Log("SL4B_FailoverConfiguration: Failed to parse RttpSite");
			throw (e);
		}
	};

	
	this.parseServerPair = function(SL_BU)
	{
		try
		{
			SL4B_Failover_Log("\tparseServerPair " + SL_BU.tagName);
			var l_pChildren = SL_BU.childNodes;
			var l_oPrimaryServer = null;
			var l_oBackupServer = null;
			
			for (var i=0; i< l_pChildren.length; i++)
			{
				l_oChild = l_pChildren[i];
				if (l_oChild.tagName == "primaryserver")
				{
					l_oPrimaryServer = new SL4B_FailoverServer();
					l_oPrimaryServer.parseServer(l_oChild);
					this.SL_VW.push(l_oPrimaryServer);
				}
				else if (l_oChild.tagName == "backupserver")
				{
					l_oBackupServer = new SL4B_FailoverServer();
					l_oBackupServer.parseServer(l_oChild);
					this.SL_VY.push(l_oBackupServer);
				}
			}
			
			l_oPrimaryServer.setPairedServer(l_oBackupServer, false);
			l_oBackupServer.setPairedServer(l_oPrimaryServer, true);
		}
		catch (e)
		{
			SL4B_Failover_Log("SL4B_FailoverConfiguration: Failed to parse ServerPair");
			throw (e);
		}
	};
	
	
	this.toString = function()
	{
		var SL_ALa = "";
		SL_ALa += "Name = " + this.SL_ve + ", ";
		SL_ALa += "\nFailOverAlgorithm = " + this.SL_VV + ", ";

		SL_ALa += "\nPrimary Servers:";
		for (var i=0; i<this.SL_VW.length; i++)
		{
			SL_ALa += this.SL_VW[i].toString();
		}

		SL_ALa += "\nBackup Servers:";
		for (var i=0; i<this.SL_VY.length; i++)
		{
			SL_ALa += this.SL_VY[i].toString();
		}
		
		return SL_ALa;
	};
}



function SL4B_FailoverServer()
{
	
	this.SL_WW = null;

	
	this.SL_ve = null;

	
	this.SL_WG = new Array();

	
	this.SL_Vp = new Object();

	
	this.SL_WY = 1;

	
	this.SL_WZ = null;
	
	
	this.SL_Vg = false;

	
	this.SL_Vh = false;

	
	this.SL_Vx = 0;

	
	this.SL_Vy = 0;

	
	this.getName = function()
	{
		return this.SL_ve;
	};

	this.getAddress = function()
	{
		return this.SL_WW;
	};

	this.getConnections = function()
	{
		return this.SL_WG;
	};

	this.getPorts = function()
	{
		return this.SL_Vp;
	};

	this.getPairedServer = function()
	{
		return this.SL_WZ;
	};

	this.setPairedServer = function(l_oServer, l_bBackup)
	{
		this.SL_WZ = l_oServer;
		this.SL_Vg = l_bBackup;
	};

	this.isBackup = function()
	{
		return this.SL_Vg;
	};

	this.getWeight = function()
	{
		return this.SL_WY;
	};

	this.getWeightStart = function()
	{
		return this.SL_Vx;
	};
	
	this.getWeightEnd = function()
	{
		return this.SL_Vy;
	};

	this.setWeightStart = function(SL_BL)
	{
		this.SL_Vx = SL_BL;
	};
	
	this.setWeightEnd = function(SL_BL)
	{
		this.SL_Vy = SL_BL;
	};

	this.isTried = function()
	{
		return this.SL_Vh;
	};

	this.setTried = function(l_bValue)
	{
		this.SL_Vh = l_bValue;
	};


	
	this.parseServer = function(SL_BU)
	{
		try
		{
			SL4B_Failover_Log("\tparseServer " + SL_BU.tagName);
			var l_pChildren = SL_BU.childNodes;
			for (var i=0; i< l_pChildren.length; i++)
			{
				l_oChild = l_pChildren[i];
				if (l_oChild.tagName == "address")
				{
					this.SL_WW = l_oChild.firstChild.nodeValue;
				}
				else if (l_oChild.tagName == "name")
				{
					this.SL_ve = l_oChild.firstChild.nodeValue;
				}
				else if (l_oChild.tagName == "connections")
				{
					this.parseConnections(l_oChild);
				}
				else if (l_oChild.tagName == "ports")
				{
					this.parsePorts(l_oChild);
				}
				else if (l_oChild.tagName == "weight")
				{
					this.SL_WY = parseInt(l_oChild.firstChild.nodeValue);
				}
			}
		}
		catch (e)
		{
			SL4B_Failover_Log("SL4B_FailoverConfiguration: Failed to parse Server");
			throw (e);
		}
	};

	
	this.parseConnections = function(SL_BU)
	{
		SL4B_Failover_Log("\tpa