function clsGlobalVars(sDataDomain){
	//REQUIRED -----------------------------------------------------------------------
	//Inherit base objects
	
	//Declare constants

	//Declare dependant objects
	
	//Declare object attributes
	var mdtServerStarted = null;
	var msObjectId = "";

	//Declare object methods
	this.Main = Main_;
	this.GetObjectId = GetObjectId_;
	this.Destroy = Destroy_;

	//-----------------------------------------------------------------------
	
	//OPTIONAL: Declare constants

	//OPTIONAL: Declare dependant objects

	//OPTIONAL: Declare object attributes
	var smDataDomain = sDataDomain || "cts.coc.gc";
	
	//OPTIONAL: Declare object methods
	this.dec2hex = dec2hex_;
	this.padString = padString_;
	this.hex2dec = hex2dec_;		
	this.TimeRandomNumber = TimeRandomNumber_;
	this.GUID = GUID_;
	this.SetGlobalVars = SetGlobalVars_;
	
	//class constructor
	this.Main();

	//REQUIRED METHODS-------------------------------------------------------
	function Main_(){
		mdtServerStarted = new Date();
		this.SetGlobalVars();
	}

	function GetObjectId_(){
		return msObjectId;
	}

	function Destroy_(){

	}

	//OPTIONAL METHODS-------------------------------------------------------
	function SetGlobalVars_(sDataDomain){

	}


	function TimeRandomNumber_(iSize){

	}
			
	function GUID_(sType){
	
	}


	function dec2hex_(lngDecVal) {

    	}

    function hex2dec_(HexVal) {

	}

	function padString_(strVar, strChar, intCount){

	}
}








function  clsClientCookie(oWindow){
	//object attributes

	//object methods
	this.DeleteAllCookies = DeleteAllCookies_;
	this.getCookieData = getCookieData_;
	this.setCookie = setCookie_;
	var ltrim = ltrim_;
	
	function DeleteAllCookies_(){

	}
	
	function getCookieData_(sLabel){
		var i = 0;

		try{
			var mycookie = document.cookie;
			var fixed_cookie = unescape(mycookie);
			var thepairs = fixed_cookie.split(";");

			for (i=0;i<thepairs.length;i++){
				var pair = thepairs[i].split("=");
				if (ltrim(pair[0]) == sLabel){
					if (pair[1] != "_NULL"){
						return pair[1];
					}else{
						return "";
					}
				}
			}
			return "";
		}catch(err){
			return "";
		}
	}

	function setCookie_(sName, sValue, lNumSeconds){
		lNumSeconds = lNumSeconds || (28 * 24 * 60 * 60 * 1000);

		var today = new Date();
		var toexpire = new Date(today.getTime() + (lNumSeconds * 1000));
		var expdate = "; expires=" + toexpire.toGMTString();
		
		if (sValue == ""){
			sValue = "_NULL";
		}
		document.cookie = sName + "=" + sValue + expdate;
	}
	
	function ltrim_(value){
	  if (typeof(value) == "undefined") { return "undefined"; }
	  if (value.length == 0) { return ""; }
	  
	  var firstval = -1;
	  for (i = 0; i < value.length; i++) {
	    if (value.charAt(i) != " ") {
	      firstval = i;
	      i = value.length;
	    }
	  }
	  
	  if (firstval == -1) { return ""; }

	  return value.substring(firstval, value.length);
	}
}








function clsCreator(boIsRunAtServer){
	var boIsRunAtServer_ = boIsRunAtServer || false;
	
	//Constants
	this.SCOPE_GLOBAL_ = 0;
	this.SCOPE_CLASS_ = 1;
	this.TYPE_PRIVATE_ = 2;
	this.TYPE_PUBLIC_ = 3;
	
	//Dependant Objects
	if (!boIsRunAtServer_){
		var oTransport_ = new clsTransport();
	}else{
		var oTransport_ = new clsServerTransport();
	}
	var oCollection_ = new clsCollection();
	oObjectRef_ = null;

	this.FactoryMethod = FactoryMethod_;
	this.UIButton = UIButton_;
	this.UIImageViewer = UIImageViewer_;

	function UIButton_(sTemplate){
		return this.FactoryMethod(ogGlobalVars.UIC_BUTTON_OBJNAME_, ogGlobalVars.UIC_BUTTON_CLSNAME_, ogGlobalVars.UIC_BUTTON_HTTPLOC_);
	}

	function UIImageViewer_(sTemplate){
		return this.FactoryMethod(ogGlobalVars.UIC_IMAGEVIEWER_OBJNAME_, ogGlobalVars.UIC_IMAGEVIEWER_CLSNAME_, ogGlobalVars.UIC_IMAGEVIEWER_HTTPLOC_);
	}

	function FactoryMethod_(sObjectName, sClassName, sObjectSource, boIsInheritable, oObjectRef, sScope, sType, boIsAsync, oNotifyObject, boIsDisableCache){
		var sObjectScript = "";
		
		boIsInheritable = boIsInheritable || false;
		oObjectRef = oObjectRef || null;
		sScope = sScope || this.SCOPE_GLOBAL_;
		sType = sType || this.TYPE_PUBLIC_;
		boIsAsync = boIsAsync || false;
		oNotifyObject = oNotifyObject || null;
		boIsDisableCache = boIsDisableCache || false;

	//alert(oCollection_.Size());
		
		oObjectRef_ = oObjectRef;
		try{
			if (eval(sObjectName)){
				return eval(sObjectName);
			}else{
				if (!boIsAsync){
					if (!boIsDisableCache){
						sObjectScript = oCollection_.Item(ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource);
						if (sObjectScript == null){
							if (!boIsRunAtServer_){
								sObjectScript = oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource, boIsAsync);
								oCollection_.Add(sObjectScript, ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource);
							}else{
								sObjectScript = oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, ogGlobalVars.LIB_OBJECTLOC_ + sObjectSource, boIsAsync);
							}
						}
					}else{
						if (!boIsRunAtServer_){
							sObjectScript = oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource, boIsAsync);
							oCollection_.Add(sObjectScript, ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource);
						}else{
							sObjectScript = oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, ogGlobalVars.LIB_OBJECTLOC_ + sObjectSource, boIsAsync);
						}
					}
					eval(sObjectScript);
					if (!boIsInheritable){
						return eval("new " + sClassName + "()");
					}else{
						eval(sClassName + ".call(oObjectRef_)");
					}
				}else{
					oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource, boIsAsync, oNotifyObject, "oCreator_", "FactoryMethod", sObjectName, sClassName);
				}
			}
		}catch(err){
			if (!boIsAsync){
				sObjectScript = oCollection_.Item(ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource);
				if (sObjectScript == null){
					if (!boIsRunAtServer_){
						sObjectScript = oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource, boIsAsync);
						oCollection_.Add(sObjectScript, ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource);
					}else{
						sObjectScript = oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, ogGlobalVars.LIB_OBJECTLOC_ + sObjectSource, boIsAsync);
					}
				}
				eval(sObjectScript);
				if (!boIsInheritable){
					return eval("new " + sClassName + "()");
				}else{
					eval(sClassName + ".call(oObjectRef_)");
				}
			}else{
				oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, ogGlobalVars.LIB_HTTP_OBJECTLOC_ + sObjectSource, boIsAsync, oNotifyObject, "oCreator_", "FactoryMethod", sObjectName, sClassName);
			}
		}
	}
	
}//end clsCreator









function clsCollection(){
	//REQUIRED -----------------------------------------------------------------------
	//Inherit base objects
	
	//Declare constants

	//Declare object properties

	//Declare dependant objects
	var oKeyRegistry_ = new clsDMPParser();

	//Declare object attributes
	var lSize = 0;
    	
	//Declare object methods
	var GetItemIndex = GetItemIndex_;
	this.Item = Item_;
	this.Load = Load_;
	this.Add = Add_;
	this.Remove = Remove_;
	this.IsEmpty = IsEmpty_;
	this.Size = Size_;
	this.RemoveAll = RemoveAll_;
	this.Clone = Clone_;
	//-----------------------------------------------------------------------
	
	//OPTIONAL: Declare constants
	
	//OPTIONAL: Declare object attributes
	
	//OPTIONAL: Declare object methods

	//class constructor
	oKeyRegistry_.create();
	
	//METHODS -----------------------------------------------------------------------
	function Load_(sMethod, sSourceObject, sItemName, sQuery, intDriverType, strServerName, strDataStoreName, strUId, strPwd, boIsRunFromServer, sPrimaryKeyName, iMaxSize){
		iMaxSize = iMaxSize || 0;
		
		var sCollectionValue = "";
		var iObjectCount = 0;
		
		this.RemoveAll();

		if (sMethod == "sql"){
			var oRecordSet_ = new cModel();
			oRecordSet_.setProperties("collectiondoc", ogGlobalVars.ENTITY_RPO_DRIVERLOC_, boIsRunFromServer, sPrimaryKeyName);
			oRecordSet_.setDataSource(false, intDriverType, strServerName, strDataStoreName, strUId, strPwd);
			oRecordSet_.initialize();
			//oRecordSet_.executeSQL("", sSourceObject, sQuery, "", true, "20", "0");
			oRecordSet_.executeSQL("", sSourceObject, sQuery, "", true);
			if (sSourceObject != ""){
				var iObjectCount = oRecordSet_.objectLength(sSourceObject);
				if (iObjectCount > 0){
					oRecordSet_.createModelView("", sSourceObject);
				}
				if (iMaxSize > 0 && iMaxSize <= iObjectCount){
					iObjectCount = iMaxSize;
				}
				for(var i=0;i<iObjectCount;i++){
					sCollectionValue = oRecordSet_.readModelViewObjectProperty("", sItemName, i);
					this.Add(sCollectionValue);
					window.status = "Adding record to collection: " + sCollectionValue;
				}
				oRecordSet_.clearModelView();
			}
			oRecordSet_ = null;
		}
		return this.Size();
	}

	function Item_(lIndex){
		if (isNaN(lIndex)){
			lIndex = GetItemIndex(lIndex);
		}
		
		if (lIndex < 0 || lIndex > this.length - 1){
			return null;
		}else{
			return this[lIndex];
		}
	}
	
	function Add_(newItem, sKey){
		sKey = sKey || "";

		if (oKeyRegistry_.get(sKey) == ""){
			if (newItem == null){
				return;
			}else{
				lSize++;
			  	this[(lSize - 1)] = newItem;
			  	if (sKey != ""){
			  		oKeyRegistry_.add(sKey, (lSize - 1));
			  	}
			}
		}
	}

	function Remove_(index){
		if (index < 0 || index > this.length - 1){
			return;
		}else{
			this[index] = null;
			for (var i = index; i <= lSize; i++){
		  		this[i] = this[i + 1];
		  	}
		  	lSize--;
		}
	 }

	function IsEmpty_(){
		return lSize == 0;
	}
     
	function Size_(){
		return lSize;
	}

	function RemoveAll_(){
		for (var i = 0; i < lSize; i++){
			this[i] = null;
		}
	  	lSize = 0;
	}

	function Clone_(){
		var c = oCreator_.FactoryMethod("oCollection", "cCollection", "cCollection.js", true, this);
	  
		for (var i = 0; i < lSize; i++){
	    	c.Add(this[i]);
		}
	  	return c;
	}
	
	function GetItemIndex_(sKey){
		
		sIndex = oKeyRegistry_.get(sKey);
		if (sIndex != ""){
			return Number(sIndex);
		}else{
			return -1;
		}
	}
}//end clsCollection









function clsTransport(){



}//end clsTransport















function clsDMPParser(sMessage){

	// constants: 
	this.ACTION_AUTHORIZE_ = "Authorize"; 
	this.ACTION_DEBIT_ = "Debit"; 
	this.ACTION_NONE_ = "None"; 
	
	this.TYPE_AUTHSTATUS_ = "Authorization_Status";
	this.TYPE_DEBITSTATUS_ = "Debit_Status";
	this.TYPE_ERROR_ = "ERROR";
	this.TYPE_ACTION_ = "Action";
	this.TYPE_DATA_ = "Data";
	this.TYPE_COLLECTION_ = "Collection";
	
	//Declare object properties
	this.oXMLAccess_ = new clsXMLAccess;
	
	this.sDMPMessage_ = sMessage || "";

	//Declare object methods
	this.initialize = initialize_;
	this.send = send_;
	this.receive = receive_;
	this.loadResponse = loadResponse_;
	this.add = add_;
	this.addText = addText_;
	this.get = get_;
	this.addImage = addImage_;
	this.getMessages = getMessages_;
	this.RefreshSetImages = RefreshSetImages_;
	this.create = create_;
	this.setHeaderAction = setHeaderAction_;
	this.setHeaderType = setHeaderType_;
	this.getAction = getAction_;
	this.getType = getType_;
	this.getHeaderType = getHeaderType_;
	this.getHeaderAction = getHeaderAction_;
	this.getNumMessages = getNumMessages_;
	this.getByIndex = getByIndex_;
	this.remove = remove_;
	this.getXMLDoc = getXMLDoc_;
	this.report = report_;
	this.Filter = Filter_;
	this.UnFilter = UnFilter_;

	function initialize_(){
		this.oXMLAccess_.initialize();
		if (sMessage == ""){
		
		}else{
			this.oXMLAccess_.loadDocument(sMessage, false, false, false);
		}
		
		return 1;
	}
	
	function create_(){
		this.oXMLAccess_.initialize();
		this.oXMLAccess_.loadDocument("<dmp />", false, false, false);
		this.oXMLAccess_.addElement("/dmp", "type", "", 0);
		this.oXMLAccess_.addElement("/dmp", "action", "", 0);
		this.oXMLAccess_.addElement("/dmp", "messages", "", 0);
		this.oXMLAccess_.addElement("/dmp/messages", "default_set", "", 0);		
		
		this.setHeaderType();
		this.setHeaderAction();
	}
	
	
	function send_(forBrowser, boIsUseHTMLCodeSet, boIsFormattedXML){
		forBrowser = forBrowser || false;
		boIsUseHTMLCodeSet = boIsUseHTMLCodeSet || false;
		boIsFormattedXML = boIsFormattedXML || false;
		
		var sBrowserXML = "";
		//forBrowser = true;
		if (forBrowser){
			sBrowserXML = this.oXMLAccess_.getXML(forBrowser, boIsFormattedXML);
			re = /&lt;message/gi;
			sBrowserXML = sBrowserXML.replace(re, "&#13;&lt;message");
			//re = /'/gi;
			//sBrowserXML = sBrowserXML.replace(re, "&#39;");	
			//re = /</gi;
			//sBrowserXML = sBrowserXML.replace(re, "&lt;");
			//re = />/gi;
			//sBrowserXML = sBrowserXML.replace(re, "&gt;");
			//re = /"/gi;
			//sBrowserXML = sBrowserXML.replace(re, "'");
			return sBrowserXML;
		}else{
			sBrowserXML = this.oXMLAccess_.getXML();
			if (boIsUseHTMLCodeSet){
				re = /'/gi;
				sBrowserXML = sBrowserXML.replace(re, "&#39;");
			}
			re = /&lt;/gi;
			sBrowserXML = sBrowserXML.replace(re, "<");
			re = /&gt;/gi;
			sBrowserXML = sBrowserXML.replace(re, ">");
			//re = /"/gi;
			//sBrowserXML = sBrowserXML.replace(re, "'");
			return sBrowserXML;
		}
	}
	
	function receive_(sMessage){
		this.sDMPMessage_ = unescape(sMessage);
		this.oXMLAccess_.initialize();
		if (this.sDMPMessage_ == ""){
			
		}else{
			this.oXMLAccess_.loadDocument(this.sDMPMessage_, false, false, false);
		}
			
		return 1;
	}
	
	function loadResponse_(sResponseObj){
		var sXResponseObj = "";
		
		this.receive(sResponseObj);
		sXResponseObj = this.getXMLDoc("response", "dmp");
		this.receive(sXResponseObj);
		return sXResponseObj;
	}
	
	function addText_(sMessageName, sMessageValue, boIsInSet, sSetName, sMessageType, sMessageAction){
		var iNumParams = 0;
		var iNodeNdx = -1;
		
		boIsInSet = boIsInSet || false;
		sSetName = sSetName || "default_set";
		sMessageType = sMessageType || this.TYPE_DATA_;
		sMessageAction = sMessageAction || this.ACTION_NONE_;
		
		
		iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/message", "name", sMessageName);
		if (iNodeNdx < 0){
			iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/" + sSetName + "/message", "name", sMessageName);
			if (iNodeNdx < 0){
				this.oXMLAccess_.addElement("/dmp/messages", "message", sMessageValue, 0, "");
				iNumParams = this.oXMLAccess_.elementNodeCount("/dmp/messages/message");
				
				this.oXMLAccess_.addAttribute("/dmp/messages/message", "type", "", iNumParams - 1, sMessageType);
				this.oXMLAccess_.addAttribute("/dmp/messages/message", "action", "", iNumParams - 1, sMessageAction);
				this.oXMLAccess_.addAttribute("/dmp/messages/message", "name", "", iNumParams - 1, sMessageName);
				
				this.oXMLAccess_.updateElement("/dmp/messages/message", sMessageValue, iNumParams - 1);
				return 1;
			}else{
				this.oXMLAccess_.updateElement("/dmp/messages/" + sSetName + "/message", sMessageValue, iNodeNdx);
				return 1;
			}
		}else{
			this.oXMLAccess_.updateElement("/dmp/messages/message", sMessageValue, iNodeNdx);
			return 1;
		}
	}
	
	
	function add_(sMessageName, sMessageValue, boIsInSet, sSetName, sMessageType, sMessageAction){
		var iNumParams = 0;
		var iNodeNdx = -1;
		
		boIsInSet = boIsInSet || false;
		sSetName = sSetName || "default_set";
		sMessageType = sMessageType || this.TYPE_DATA_;
		sMessageAction = sMessageAction || this.ACTION_NONE_;

		if (sMessageName != ""){
			if (!boIsInSet){
				iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/message", "name", sMessageName);
				if (iNodeNdx < 0){
					iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/" + sSetName + "/message", "name", sMessageName);
					if (iNodeNdx < 0){
						this.oXMLAccess_.addElement("/dmp/messages", "message", "", 0);
						iNumParams = this.oXMLAccess_.elementNodeCount("/dmp/messages/message");
						
						this.oXMLAccess_.addAttribute("/dmp/messages/message", "type", "", iNumParams - 1, sMessageType);
						this.oXMLAccess_.addAttribute("/dmp/messages/message", "action", "", iNumParams - 1, sMessageAction);
						this.oXMLAccess_.addAttribute("/dmp/messages/message", "name", "", iNumParams - 1, sMessageName);
						
						this.oXMLAccess_.updateElement("/dmp/messages/message", sMessageValue, iNumParams - 1);
						return 1;
					}else{
						this.oXMLAccess_.updateElement("/dmp/messages/" + sSetName + "/message", sMessageValue, iNodeNdx);
						return 1;
					}
				}else{
					this.oXMLAccess_.updateElement("/dmp/messages/message", sMessageValue, iNodeNdx);
					return 1;
				}
			}else{
				iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/" + sSetName + "/message", "name", sMessageName);
				if (iNodeNdx < 0){
					this.oXMLAccess_.addElement("/dmp/messages/" + sSetName, "message", "", 0);
					iNumParams = this.oXMLAccess_.elementNodeCount("/dmp/messages/" + sSetName + "/message");
					this.oXMLAccess_.addAttribute("/dmp/messages/" + sSetName + "/message", "type", "", iNumParams - 1, sMessageType);
					this.oXMLAccess_.addAttribute("/dmp/messages/" + sSetName + "/message", "action", "", iNumParams - 1, sMessageAction);
					this.oXMLAccess_.addAttribute("/dmp/messages/" + sSetName + "/message", "name", "", iNumParams - 1, sMessageName);
					this.oXMLAccess_.updateElement("/dmp/messages/" + sSetName + "/message", sMessageValue, iNumParams - 1);
					return 1;
				}else{
					this.oXMLAccess_.updateElement("/dmp/messages/" + sSetName + "/message", sMessageValue, iNodeNdx);
					return 1;
				}			
			}
		}else{
			return 0;
		}
	}
	
	function get_(sMessageName, sXMLDocRootNodeName, sSetName, boIsFastAccess){
		var oTempXML = new clsXMLAccess;
		var boIsXMLDocExtracted = false;
		var iNodeNdx = 0;
		var xmlDocNode;
		var iNodeNdx = 0;
		
		sXMLDocRootNodeName = sXMLDocRootNodeName || sMessageName;
		sSetName = sSetName || "default_set";
		boIsFastAccess = boIsFastAccess || false;
		
		if (boIsFastAccess){
			try{
				iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/message", "name", sMessageName);				
				if (iNodeNdx > -1){
					return this.oXMLAccess_.readElement("/dmp/messages/message", iNodeNdx);
				}else{
					iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/" + sSetName + "/message", "name", sMessageName);
					if (iNodeNdx > -1){
						return this.oXMLAccess_.readElement("/dmp/messages/" + sSetName + "/message", iNodeNdx);
					}else{
						return "";
					}
				}
			}catch(err){
				return "";
			}
		}

		try{
			if (sMessageName != "" && sXMLDocRootNodeName != ""){
				iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/message", "name", sMessageName);
				//alert(sMessageName + ": " + sXMLDocRootNodeName + ": " + iNodeNdx);
				if (iNodeNdx > -1){
					xmlDocNode = this.oXMLAccess_.getXmlNode("/dmp/messages/message", iNodeNdx);
					oTempXML.loadDocument(xmlDocNode.xml, false, false, false);
					xmlDocNode = oTempXML.getXmlNode("/message/" + sXMLDocRootNodeName, 0);
					return xmlDocNode.xml;
				}else{
					iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/" + sSetName + "/message", "name", sMessageName);
					if (iNodeNdx > -1){
						xmlDocNode = this.oXMLAccess_.getXmlNode("/dmp/messages/" + sSetName + "/message", iNodeNdx);
						oTempXML.loadDocument(xmlDocNode.xml, false, false, false);
						xmlDocNode = oTempXML.getXmlNode("/message/" + sXMLDocRootNodeName, 0);
						return xmlDocNode.xml;
					}					
				}
			}else{
				boIsXMLDocExtracted = false;
			}
		}
		catch(err){
			boIsXMLDocExtracted = false;
		}

		if(!boIsXMLDocExtracted){
			try{
				if (sMessageName != ""){
					iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/message", "name", sMessageName);
					if (iNodeNdx > -1){
						return this.oXMLAccess_.readElement("/dmp/messages/message", iNodeNdx);
					}else{
						iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/" + sSetName + "/message", "name", sMessageName);
						if (iNodeNdx > -1){
							return this.oXMLAccess_.readElement("/dmp/messages/" + sSetName + "/message", iNodeNdx);
						}else{
							return "";
						}
					}
				}else{
					return "";
				}
			}
			catch(err){
				return "";
			}
		}
	}

	function getMessages_(){
		try{
			xmlDocNode = this.oXMLAccess_.getXmlNode("/dmp/messages", 0);
			return xmlDocNode.xml;
		}catch(err){
			return "";
		}
	}
	
	function addImage_(sImageId, sSetName, sImageLocation){
		var sImage = "";
		var sModel = "";
		var sRootElement = "";
		
		sSetName = sSetName || "default_set";
		sImageLocation = sImageLocation || ogGlobalVars.MODELSTATE_IMAGES_HTTPLOC_;
		
		if (oSystemVarDoc_.get("REFRESH_MI_OVERRIDE") != "1"){
			sImage = oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, sImageLocation + sImageId + ".sif", false);
			if (sImage != "-1"){
				sImage = sImage.slice(sSetName.length + 2, sImage.length - (sSetName.length + 3));
				this.oXMLAccess_.removeElement("/dmp/messages/" + sSetName, 0);
				this.oXMLAccess_.addElement("/dmp/messages", sSetName, "", 0);
				this.oXMLAccess_.updateElement("/dmp/messages/" + sSetName, sImage, 0);
				this.oXMLAccess_.loadDocument(this.oXMLAccess_.getXML(), false, false, false);
				iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/" + sSetName + "/message", "name", "boIsCancelDisplayReq_");
				return true;
			}else{
				return false;
			}
		}else{
			return false;
		}
	}

	function RefreshSetImages_(oGlobalVarDoc, sImageClassName, sImageClassLoc, sImageId, sSetName, boIsRunAtServer){
		oGlobalVarDoc = oGlobalVarDoc || null;
		sImageClassName = sImageClassName || "";
		sImageClassLoc = sImageClassLoc || "";
		sSetName = sSetName || "default_set";
		boIsRunAtServer = boIsRunAtServer || false;
		
		window.status = "Updating set image...";
		if (!boIsRunAtServer){
			var oSIManager_ = oCreator_.FactoryMethod("oSIManager_", sImageClassName, "mic/" + sImageClassLoc);
		}else{
			var oSIManager_ = oCreator_.FactoryMethod("oSIManager_", sImageClassName, "mic\\" + sImageClassLoc);
		}
		var oModel = new cxDMPParser()

		oSIManager_.SetProperties(oModel, sSetName, boIsRunAtServer);
		oSIManager_.Initialize(oGlobalVarDoc);
		oSIManager_.CreateImage(sImageId);
		
		this.addImage(sImageId);
		oModel = null;
		oSIManager_ = null;

		window.status = "Ready";
	}
	
	function getXMLDoc_(sMessageName, sXMLDocRootNodeName){
		var oTempXML = new clsXMLAccess;
		var iNodeNdx = 0;
		var xmlDocNode;
		
		try{
			if (sMessageName != "" && sXMLDocRootNodeName != ""){
				iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/message", "name", sMessageName);
				if (iNodeNdx > -1){
					xmlDocNode = this.oXMLAccess_.getXmlNode("/dmp/messages/message", iNodeNdx);
					oTempXML.loadDocument(xmlDocNode.xml, false, false, false);
					xmlDocNode = oTempXML.getXmlNode("/message/" + sXMLDocRootNodeName, 0);
					return xmlDocNode.xml;
				}
			}else{
				return "";
			}
		}
		catch(err){
			return "";
		}
	}	
	
	
	function remove_(sMessageName){
	
		if (sMessageName != ""){
			iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/message", "name", sMessageName);
			if (iNodeNdx > -1){
				this.oXMLAccess_.removeElement("/dmp/messages/message", iNodeNdx);
				return 1;
			}
		}else{
			return 0;
		}	
		
	}
	
	function getByIndex_(sMessageName, iNodeNdx){
		var totMessages = 0;
		var sMName = "";
		var i = 0;
		
		if (sMessageName != ""){
			totMessages = this.getNumMessages();
			for (i=0; i<totMessages; i++){
				sMName = this.oXMLAccess_.readAttribute("/dmp/messages/message", "name", i);
				if (sMName == sMessageName){
					if (i == iNodeNdx){
						return this.oXMLAccess_.readElement("/dmp/messages/message", i);
					}
				}
			}
		}	
		return "";
	}
	
	function getNumMessages_(){
		return this.oXMLAccess_.elementNodeCount("/dmp/messages/message");
	}

	function report_(){
		var i = 0;
		var sMessageName = "";
		var sMessageValue = "";
		var sReport = "";
		var sName = "";
		var sData = "";
		var iNumMessages = 0;
		
		try{
			iNumMessages = this.oXMLAccess_.elementNodeCount("/dmp/messages/message");
		}catch(err){
			iNumMessages = 0;
		}
		
		sReport = sReport + "<table style=\"FONT-SIZE: 11pt;FONT-FAMILY: Arial, 'Courier New';\" align=\"left\" cellpadding=\"0\" cellspacing=\"0\">";
		
		for (i=0;i<iNumMessages;i++){
			sName = this.oXMLAccess_.readAttribute("/dmp/messages/message", "name", i);
			sData = this.get(this.oXMLAccess_.readAttribute("/dmp/messages/message", "name", i));
			re = /</gi;
			sData = sData.replace(re, "&lt;");
			re = />/gi;
			sData = sData.replace(re, "&gt;");
			
			sName = sName.slice(0, 75);
			sData = sData.slice(0, 45);
			
			sReport = sReport + "<tr>";
			sReport = sReport + "	<td><b>" + sName + "</b></td>";
			sReport = sReport + "	<td>" + sData + "</td>";
			sReport = sReport + "</tr>";
		}
		sReport = sReport + "</table>";		
			
		return sReport;
	}
	
	function setHeaderAction_(sActionValue){

		sActionValue = sActionValue || this.ACTION_NONE_;
		this.oXMLAccess_.updateElement("/dmp/action", sActionValue, 0);
	}	
	
	function setHeaderType_(sTypeValue){

		sTypeValue = sTypeValue || this.TYPE_DATA_;
		this.oXMLAccess_.updateElement("/dmp/type", sTypeValue, 0);
	}
	
	function getHeaderType_(){
		return this.oXMLAccess_.readElement("/dmp/type", 0);
	}
	
	function getHeaderAction_(){
		return this.oXMLAccess_.readElement("/dmp/action", 0);
	}
	
	function getAction_(sMessageName){
		var iNodeNdx = 0;
		
		if (sMessageName != ""){
			iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/message", "name", sMessageName);
			if (iNodeNdx > -1){
				return this.oXMLAccess_.readAttribute("/dmp/messages/message", "action", iNodeNdx);
			}
		}else{
			return "";
		}
	}
	
	function getType_(sMessageName){
		var iNodeNdx = 0;
		
		if (sMessageName != ""){
			iNodeNdx = this.oXMLAccess_.findNodeByAttribute("/dmp/messages/message", "name", sMessageName);
			if (iNodeNdx > -1){
				return this.oXMLAccess_.readAttribute("/dmp/messages/message", "type", iNodeNdx);
			}
		}else{
			return "";
		}
	}

	function UnFilter_(sText){
		var newString, separator;

		if (!sText)
			newString = "";
		else
			try{
				newString = sText;
				
				separator = /&amp;#92;/gi;
				newString = newString.replace(separator, "\\");
				separator = /&#60;/gi;
				newString = newString.replace(separator, "\<");
				separator = /&#62;/gi;
				newString = newString.replace(separator, "\>");
				separator = /&#32;/gi;
				newString = newString.replace(separator, "\ ");	
				separator = /&#34;/gi;
				newString = newString.replace(separator, "\"");	
				separator = /&gt;/gi;
				newString = newString.replace(separator, "\>");	
				separator = /&lt;/gi;
				newString = newString.replace(separator, "\<");
				separator = /&amp;gt;/gi;
				newString = newString.replace(separator, "\>");	
				separator = /&amp;lt;/gi;
				newString = newString.replace(separator, "\<");
				separator = /&amp;#13;/gi;
				newString = newString.replace(separator, "");
				separator = /&#150;/gi;
				newString = newString.replace(separator, "\-");
			}
			catch(err){
				return sText;
			}								
		return newString;
	}

	function Filter_(sText){
		var newString, separator;

		if (!sText)
			newString = "";
		else
			try{
				newString = sText;
				
				separator = /\\/gi;
				newString = newString.replace(separator, "&amp;#92;");					
				separator = /\</gi;
				newString = newString.replace(separator, "&#60;");
				separator = /\>/gi;
				newString = newString.replace(separator, "&#62;");		
				separator = /\ /gi;
				newString = newString.replace(separator, "&#32;");	
				separator = /\"/gi;
				newString = newString.replace(separator, "&#34;");	
				separator = /\>/gi;
				newString = newString.replace(separator, "&gt;");	
				separator = /\</gi;
				newString = newString.replace(separator, "&lt;");
				separator = /\-/gi;
				newString = newString.replace(separator, "&#150;");				
			}
			catch(err){
				return sText;
			}								
		return newString;
	}	
	
} //end clsDMPParser














function clsXMLAccess(){

	//XML DOMNodeType enumerated constants: 
	this.NODE_ELEMENT_ = 1; 
	this.NODE_ATTRIBUTE_ = 2; 
	this.NODE_TEXT_ = 3; 
	this.NODE_CDATA_SECTION_ = 4; 
	this.NODE_ENTITY_REFERENCE_ = 5; 
	this.NODE_ENTITY_ = 6; 
	this.NODE_PROCESSING_INSTRUCTION_ = 7; 
	this.NODE_COMMENT_ = 8; 
	this.NODE_DOCUMENT_ = 9;
	this.NODE_DOCUMENT_TYPE_ = 10; 
	this.NODE_DOCUMENT_FRAGMENT_ = 11; 
	this.NODE_NOTATION_ = 12; 

	this.NAMESPaCE_DTYPE_MICROSOFT_ = "urn:schemas-microsoft-com:datatypes";

	this.NODETYPE_BINARY_BASE64_ = "bin.base64";

	var RSVRD_ATTNAME_NODEINDEXID_ = "_NODEINDEXID";

	var TEMP_NODE_SEARCHKEY_ = "*";

	//Declare object properties
	this.oDOMGeneric_ = new ActiveXObject("Microsoft.XMLDOM");
	this.oRootGeneric_ = new ActiveXObject("Microsoft.XMLDOM");
	this.oFTDom_ = new ActiveXObject("Microsoft.XMLDOM");
	this.oParseErr_ = new ActiveXObject("Microsoft.XMLDOM");
	var oDTDAccess_ = null;
	
	this.xmlParserValidation_;
	this.docAddress_;
	this.selNodeIdx_;

	//recursion-tracking variables
	//this.depth=0;
	//this.depthList=new Array();

	this.indent=0;

	//Declare object methods
	this.initialize = initialize_;
	this.ResetDTD = ResetDTD_;
	this.loadDocument = loadDocument_;
	this.addDocumentImage = addDocumentImage_;
	this.getDocumentImage = getDocumentImage_;
	this.getDOM = getDOM_;
	this.getXML = getXML_;
	this.getXQL = getXQL_;
	this.getError = getError_;
	this.readElement = readElement_;
	this.readAttribute = readAttribute_;
	this.readAttributeName = readAttributeName_;
	this.getXmlNode = getXmlNode_;
	this.createNodeObject = createNodeObject_;
	this.updateElement = updateElement_;
	this.updateAttribute = updateAttribute_;
	this.transformXMLNode = transformXMLNode_;
	this.cloneXmlNode = cloneXmlNode_;
	this.appendXmlNode = appendXmlNode_;
	this.createXPath = createXPath_
	this.appendXml = appendXml_;
	this.insertNode = insertNode_;
	this.addElement = addElement_;
	this.addAttribute = addAttribute_;
	this.findNodeByElement = findNodeByElement_;
	this.findNodeByAttribute = findNodeByAttribute_;
	this.findNodesByElement = findNodesByElement_;
	this.findNodesByAttribute = findNodesByAttribute_;
	this.findNodeByAttributes = findNodeByAttributes_;
	this.getRelNodeIndex = getRelNodeIndex_;
	this.getNodeIndex = getNodeIndex_;
	this.getSiblingValue = getSiblingValue_;
	this.elementNodeCount = elementNodeCount_;
	this.elementNodeCountByElement = elementNodeCountByElement_;
	this.elementNodeCountByAttribute = elementNodeCountByAttribute_;
	this.elementNodeCountByParentRef = elementNodeCountByParentRef_;
	this.attributeNodeCount = attributeNodeCount_;
	this.getMaxNodeElementIndex = getMaxNodeElementIndex_;
	this.getParentNodeIndex = getParentNodeIndex_;
	this.findNodeByParentRef = findNodeByParentRef_;
	this.getParentXPath = getParentXPath_;
	this.getChildNodeName = getChildNodeName_;
	this.validateNode = validateNode_;
	this.save = save_;
	this.initNode = initNode_;
	this.removeAllNodeId = removeAllNodeId_;
	this.removeElement = removeElement_;
	this.removeAttribute = removeAttribute_;
	this.filterCdata = filterCdata_;
	this.filterTextStream = filterTextStream_;
	this.updateCDataSection = updateCDataSection_;
	this.readCDataSection = readCDataSection_;

	this.sortOnAttribute = sortOnAttribute_;
	this.padString = padString_;
	this.dec2hex = dec2hex_;
	this.createArray = createArray_;
	this.sortCompareASC = sortCompareASC_;
	this.sortCompareDSC = sortCompareDSC_;
	
	function initialize_(){
		this.oDOMGeneric_ = new ActiveXObject("Microsoft.XMLDOM");
		this.oRootGeneric_ = new ActiveXObject("Microsoft.XMLDOM");
		this.oFTDom_ = new ActiveXObject("Microsoft.FreeThreadedXMLDOM");

		this.xmlParserValidation_ = 0;
		this.docAddress_ = "";
		this.selNodeIdx_ = 0;
		
		return this.oDOMGeneric;
	}

	function ResetDTD_(sDTDSource){
		try{
			if (oDTDAccess_ == null){
				oDTDAccess_ = oCreator_.FactoryMethod("oDTDAccess_", "cDTDAccess", "cDTDAccess.js");
			}
			oDTDAccess_.Initialize();
			oDTDAccess_.SetProperties(sDTDSource);
			return true;
		}catch(err){
			oDTDAccess_ = null;
			return false;
		}
	}

	function loadDocument_(sourceAddress, findExternals, validateFile, loadFromFile, sDTDSource, strDataTypeNameSpace, boIsDTDDeep){
		sDTDSource = sDTDSource || "";
		strDataTypeNameSpace = strDataTypeNameSpace || "";
		boIsDTDDeep = boIsDTDDeep || false;
		
		//set to true if you want oDOMGeneric_ to load the file asynchronously
		this.oDOMGeneric_.async = false;

		if (sDTDSource != ""){
			if (this.ResetDTD(sDTDSource)){
				sourceAddress = oDTDAccess_.GetElement(sourceAddress, "", "", boIsDTDDeep);
			}
		}

		//filter sourceAddress
		if(!loadFromFile){
			sourceAddress = this.filterTextStream(sourceAddress);
		}

		//load XML source into the DOM Document oDOMGeneric_
		if (loadFromFile){
			this.oDOMGeneric_.load(sourceAddress);
		}else{
			this.oDOMGeneric_.loadXML(sourceAddress);
		}

		//check that the load of the XML file into oDOMGeneric_ was successful
		this.oParseErr_ =  this.oDOMGeneric_.parseError;
		if (this.oParseErr_.errorCode) {
			return 0;
		}else{
			if (strDataTypeNameSpace != ""){
   				this.oDOMGeneric_.documentElement.setAttribute("xmlns:dt", strDataTypeNameSpace);
			}
			return 1;
		}
	}

	function addDocumentImage_(sDocImageId, boIsAppend){
		boIsAppend = boIsAppend || false;
		
		if (!boIsAppend){
			if (this.loadDocument(ogGlobalVars.DOCUMENT_IMAGES_HTTPLOC_ + sDocImageId + ".xml", false, false, true) == 1){
				return true;
			}else{
				return false;
			}
		}else{
			null;
		}
	}

	function getDocumentImage_(sDocImageId){
		sImage = oTransport_.request(oTransport_.HTTP_RESPONSETYPE_TEXT_, ogGlobalVars.DOCUMENT_IMAGES_HTTPLOC_ + sDocImageId + ".xml", false);
		if (sImage != -1){
			return sImage;
		}else{
			return "";
		}
	}

	function getXML_(forBrowser, boIsFormattedXML){
		forBrowser = forBrowser || false;
		boIsFormattedXML = boIsFormattedXML || false;
		
		var sBrowserXML = "";
		
		if (forBrowser){
			sBrowserXML = this.oDOMGeneric_.xml;
			re = /</gi;
			sBrowserXML = sBrowserXML.replace(re, "&lt;");
			re = />/gi;
			sBrowserXML = sBrowserXML.replace(re, "&gt;");
			if (boIsFormattedXML){
				re = /=\"/gi;
				sBrowserXML = sBrowserXML.replace(re, "=<font color='red'>\"");
				re = /\"&gt;/gi;
				sBrowserXML = sBrowserXML.replace(re, "\"</font>&gt;");
				re = /\"\/&gt;/gi;
				sBrowserXML = sBrowserXML.replace(re, "\"</font>/&gt;");

				re = /\" /gi;
				sBrowserXML = sBrowserXML.replace(re, "\"</font> ");

				re = /&gt;/gi;
				sBrowserXML = sBrowserXML.replace(re, "&gt;<font color='blue'>");
				re = /&lt;/gi;
				sBrowserXML = sBrowserXML.replace(re, "</font>&lt;");
			}
			return sBrowserXML;
		}else{
			return this.oDOMGeneric_.xml;
		}
	}


	function getDOM_(){
		if (this.oDOMGeneric_){
			return this.oDOMGeneric_;
		}else{
			return false;
		}
	}


	function getBrowserXML_(){
		var sBrowserXML = "";

		sBrowserXML = oDOMGeneric_.xml;
		sBrowserXML = sBrowserXML.replace("<", "&lt;");
		sBrowserXML = sBrowserXML.replace(">", "&gt;");
		
		return sBrowserXML;
	}

	function getError_(){
		return this.oParseErr_.reason;
	}

	function readElement_(sXQL, iNodeNdx){
		var oXMLNodeElement;
		var oDOMNode;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

		//get node value from node object
		if(oDOMNode){
			return oDOMNode.nodeTypedValue;
		}else{
			return "";
		}
	}

	function readCDataSection_(sXQL, iNodeNdx){
		var oChildNode;
		var currNdx = 0;
		var oXMLNodeElement;
		var oDOMNode;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

		//get node value from node object
		if(oDOMNode){
			for (currNdx = 0; currNdx < oDOMNode.childNodes.length; currNdx++) {
				//get a child node
				oChildNode = oDOMNode.childNodes.item(currNdx);	
				if (oChildNode.nodeType == this.NODE_CDATA_SECTION_){
					//read cdata section of node element
					return oDOMNode.childNodes.item(currNdx).nodeTypedValue;
				}				
			}
		}
		return "";
	}

	function updateCDataSection_(sXQL, sCDataSection, iNodeNdx){
		var oChildNode;
		var currNdx = 0;
		var oXMLNodeElement;
		var oDOMNode;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

		//get node value from node object
		if(oDOMNode){
			for (currNdx = 0; currNdx < oDOMNode.childNodes.length; currNdx++) {
				//get a child node
				oChildNode = oDOMNode.childNodes.item(currNdx);	
				if (oChildNode.nodeType == this.NODE_CDATA_SECTION_){
					//update cdata section of node element
					oDOMNode.childNodes.item(currNdx).nodeTypedValue = sCDataSection;
					return 1;
				}
			}
		}
		return 0;
	}

	function readAttribute_(sXQL, attributeName, iNodeNdx){
		var oXMLNodeElement;
		var oAttribute;
		var oDOMNode;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		try{
			oXMLNodeElement = this.oDOMGeneric_.documentElement;
			oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

			if (oDOMNode){
				oAttribute = oDOMNode.attributes.getNamedItem(attributeName);

				//get node value from node object
				if(oAttribute){
					return oAttribute.nodeValue;
				}else{
					return "";
				}
			}
		}
		catch(err){
			return "";
		}
	}
	   
	function readAttributeName_(sXQL, iNodeNdx, iAttribNdx){
		var oXMLNodeElement;
		var oAttribute;
		var oDOMNode;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

		if (oDOMNode && oDOMNode.attributes.length > 0){
			oAttribute = oDOMNode.attributes.item(iAttribNdx);
		
			//get node value from node object
			if(oAttribute){
				return oAttribute.name;
			}else{
				return "";
			}
		}else{
			return "";
		}
	}
  

	function addElement_(sXQL, sElementName, sCDataText, iNodeNdx, sNodeId, deferSave, sNodeType, sNodeValue, sNamespace, boReturnIndex){
		sNodeValue = sNodeValue || "";
		sNodeId = sNodeId || "";
		deferSave = deferSave || true;
		sNodeType = sNodeType || "";
		sCDataText = sCDataText || "";
		sNamespace = sNamespace || "";
		boReturnIndex = boReturnIndex || false;
			
		var oXMLNodeElement;
		var oAttribute;
		var oCurrNode;
		var oNewNode;
		var CDATASection;
		var iNewElementNdx = 1;

		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		//set a node pointer to insert position
		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oCurrNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);
		oNewNode = this.oDOMGeneric_.createNode(this.NODE_ELEMENT_, sElementName, sNamespace);
		oNewNode.nodeTypedValue = sNodeValue;

		//create node id key if nodeId is set
		if (sNodeId != ""){
			oAttribute = this.oDOMGeneric_.createAttribute("_nid");
			oAttribute.text = sNodeId;
			oNewNode.attributes.setNamedItem (oAttribute);

			//delete next line
			oNewNode.text = sNodeId;
		}

		if (sNodeType != ""){
			oNewNode.dataType = sNodeType;
		}

		//append new element to objDOMNode
        oCurrNode.appendChild (oNewNode);
        
		if (sCDataText != ""){
			CDATASection = this.oDOMGeneric_.createCDATASection(sCDataText);
			oNewNode.appendChild(CDATASection);
		}        
 
		if (boReturnIndex){
			oAttribute = this.oDOMGeneric_.createAttribute(RSVRD_ATTNAME_NODEINDEXID_)
			oAttribute.text = TEMP_NODE_SEARCHKEY_
			oNewNode.attributes.setNamedItem (oAttribute);
		
			iNewElementNdx = this.findNodeByAttribute(sXQL + "/" + sElementName, RSVRD_ATTNAME_NODEINDEXID_, TEMP_NODE_SEARCHKEY_);	
			this.removeAttribute(sXQL + "/" + sElementName, RSVRD_ATTNAME_NODEINDEXID_, iNewElementNdx);
		}		

   		if (deferSave != true){

   		}
   		
		return iNewElementNdx;
	}

	function addAttribute_(sXQL, sAttributeName, sFilename, iNodeNdx, sDefaultAttributeValue, deferSave){
		var oXMLNodeElement;
		var oAttribute;
		var oCurrNode;

		//sDefaultAttributeValue = sDefaultAttributeValue || "";
		deferSave = deferSave || true;

		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		//set a node pointer to insert position
		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oCurrNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

            	//create new attribute and set to current node
                oAttribute = this.oDOMGeneric_.createAttribute(sAttributeName);
                oAttribute.text = sDefaultAttributeValue;
                oCurrNode.attributes.setNamedItem (oAttribute);

    		if (deferSave != true){
        		
    		}
		
		return 1;
	}

	function cloneXmlNode_(sXQL, iNodeNdx, deep, boIsRetainAttributes, iCloneNodeIndex){
		boIsRetainAttributes = boIsRetainAttributes || false;
		iCloneNodeIndex = iCloneNodeIndex || iNodeNdx;
		
		var oXMLNodeElement;
		var oXMLNodeElement2;
		var oCurrNode;
		var oCurrNode2;
		var oNewNode;
		var sXQL_parent = "";
		var ndx = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		
		//find XQL statement of parent node
		ndx = sXQL.lastIndexOf("/");
		sXQL_parent = sXQL.substring(0, ndx);

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oXMLNodeElement2 = this.oDOMGeneric_.documentElement;
		oCurrNode = oXMLNodeElement.selectNodes(sXQL).item(iCloneNodeIndex);
		oCurrNode2 = oXMLNodeElement2.selectNodes(sXQL_parent).item(iNodeNdx);
		
		//append new node to xml document
		if(oCurrNode){
			oNewNode = oCurrNode.cloneNode(deep);
			if (!boIsRetainAttributes){
				//initialize new node
				this.initNode(oNewNode, "");
			}
			//oXMLNodeElement.appendChild (oNewNode);
			oCurrNode2.appendChild (oNewNode);
			return 1;
		}else{
			return 0;
		}
	}

	function appendXmlNode_(sXQL, oNode, iNodeNdx, deep){
		var oXMLNodeElement;
		var oXMLNodeElement2;
		var oCurrNode;
		var oCurrNode2;
		var oNewNode;
		//var sXQL_parent = "";
		//var ndx = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		
		//find XQL statement of parent node
		//ndx = sXQL.lastIndexOf("/");
		//sXQL_parent = sXQL.substring(0, ndx);

		try{
			oXMLNodeElement = this.oDOMGeneric_.documentElement;
			oXMLNodeElement2 = this.oDOMGeneric_.documentElement;
			oCurrNode = oNode;
			oCurrNode2 = oXMLNodeElement2.selectNodes(sXQL).item(iNodeNdx);
			
			//append new node to xml document
			if(oCurrNode){
				oNewNode = oCurrNode.cloneNode(deep);
				//oXMLNodeElement.appendChild (oNewNode);
				oCurrNode2.appendChild (oNewNode);
				return 1;
			}else{
				return 0;
			}
		}catch(err){
			return 0;
		}
	}


	function appendXml_(sXQL, sNewNodeXML, sNewNodeXQL, iNodeNdx, boIsDeep, boUseDTD){
		boIsDeep = boIsDeep || false;
		boUseDTD = boUseDTD || false;
		
		var oXMLNodeElement;
		var oXMLNodeElement2;
		var oCurrNode;
		var oCurrNode2;
		var oNewNode;
		
		//var sXQL_parent = "";
		//var ndx = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		
		//find XQL statement of parent node
		//ndx = sXQL.lastIndexOf("/");
		//sXQL_parent = sXQL.substring(0, ndx);

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oXMLNodeElement2 = this.oDOMGeneric_.documentElement;

		if (boUseDTD){
			sNewNodeXML = oDTDAccess_.GetElement(sNewNodeXML, "", "", boIsDeep);
		}

		//create xml node object from sXML string		
		oCurrNode = this.createNodeObject(sNewNodeXQL, sNewNodeXML);
		oCurrNode2 = oXMLNodeElement2.selectNodes(sXQL).item(iNodeNdx);

		//append new node to xml document
		if(oCurrNode){
			oNewNode = oCurrNode.cloneNode(boIsDeep);
			//oXMLNodeElement.appendChild (oNewNode);
			oCurrNode2.appendChild (oNewNode);
			return 1;
		}else{
			return 0;
		}
	}

	function createXPath_(sXPath, boIsDeep, boUseDTD, iCount){
		boIsDeep = boIsDeep || false;
		boUseDTD = boUseDTD || false;
		iCount = iCount || 0;
		
		var sPXPath = "";
		
		iNodeCount = this.elementNodeCount(sXPath);
		if (iNodeCount > 0){
			if (iCount == 0){
				sPXPath = this.getParentXPath(sXPath)
				sPNode = this.getChildNodeName(sXPath);				
				if (boUseDTD){
					this.appendXml(sPXPath, sPNode, "/" + sPNode, 0, boIsDeep, boUseDTD);
				}else{
					this.appendXml(sPXPath, "<" + sPNode + "/>", "/" + sPNode, 0, boIsDeep, boUseDTD);
				}
			}
			return sXPath;
		}else{
			sPXPath = this.createXPath(this.getParentXPath(sXPath), boIsDeep, boUseDTD, iCount + 1);
			sPNode = this.getChildNodeName(sXPath);
			if (boUseDTD){
				this.appendXml(sPXPath, sPNode, "/" + sPNode, 0, boIsDeep, boUseDTD);
			}else{
				this.appendXml(sPXPath, "<" + sPNode + "/>", "/" + sPNode, 0, boIsDeep, boUseDTD);
			}
			return sXPath;
		}
	}
		
	function getXmlNode_(sXQL, iNodeNdx){
		var oXMLNodeElement;
		var oDOMNode;
		
		try{
			//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
			oXMLNodeElement = this.oDOMGeneric_.documentElement;
			oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

			//get node value from node object
			if(oDOMNode){
				return oDOMNode;
			}else{
				return null;
			}
		}catch(err){
			return null;
		}
	}

	function removeElement_(sXQL, iNodeNdx){
		var oXMLNodeElement;
		var oDOMNode;
		var oDOMParentNode;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

		//get node value from node object
		if(oDOMNode){
			oDOMParentNode = oDOMNode.parentNode;
			
			//remove target node from xml document
            oDOMParentNode.removeChild (oDOMNode);
			return 1;
		}else{
			return 0;
		}
	}


	function removeAttribute_(sXQL, attributeName, iNodeNdx){
		var oXMLNodeElement;
		var oDOMNode;
		var oDOMParentNode;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

		//get node value from node object
		if(oDOMNode){
			//remove target node attribute from xml document
            if (oDOMNode.attributes.length > 0){
                oDOMNode.attributes.removeNamedItem (attributeName);
				return 1;
			}else{
				return 0;
			}
		}else{
			return 0;
		}
	}



	function updateElement_(sXQL, elementValue, iNodeNdx, isBinary, isCData){
		var oXMLNodeElement;
		var oDOMNode;
		var oChildNode;
		var currNdx = 0;
		 
		isBinary = isBinary || false;
		isCData = isCData || false;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

		//get node value from node object
		if(oDOMNode){
			if (isBinary){
				oDOMNode.nodeTypedValue = elementValue;
			//}else if (isCData){
				//for (currNdx = 0; currNdx < oDOMNode.childNodes.length; currNdx++) {
					//get a child node
					//oChildNode = oDOMNode.childNodes.item(currNdx);	
					//if (oChildNode.nodeType == this.NODE_CDATA_SECTION_){
						//update cdata section of node element
						//oDOMNode.childNodes.item(currNdx).nodeTypedValue = elementValue;
						//return 1;
					//}
				//}
			}else{
				oDOMNode.text = elementValue;
			}
			return 1;
		}else{
			return 0;
		}
	}


	function updateAttribute_(sXQL, attributeName, attributeValue, iNodeNdx){
		var oXMLNodeElement;
		var oAttribute;
		var oDOMNode;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);
		oAttribute = oDOMNode.attributes.getNamedItem(attributeName);

		//get node value from node object
		if(oAttribute){
			oAttribute.text = attributeValue;
			return 1;
		}else{
			return 0;
		}
	}


	function transformXMLNode_(nodStylesheet, boIsTextDocument){
		//nodStylesheet is an XML document or DOM node that consists of XSL elements that direct the transformation of this node
		var xslDoc = new ActiveXObject("Msxml.DOMDocument");
	
		boIsTextDocument = boIsTextDocument || false;
	
		//recreate xsl document
		xslDoc.async = false;
		
		if (!boIsTextDocument){
			xslDoc.loadXML(nodStylesheet.xml);
		}else{
			xslDoc.loadXML(nodStylesheet);
		}

		//transform xml document using xslDoc
   		return this.oDOMGeneric_.transformNode(xslDoc);
	}

	
	function createNodeObject_(sXQL, sNodeStructure){
		//sNodeStructure is an XML document in the form of a string
		var xslDoc = new ActiveXObject("Msxml.DOMDocument");
		var oXMLNodeElement;
		var oDOMNode;
		var oCurrNode;
		
		//recreate xsl document
		xslDoc.async = false;
		xslDoc.loadXML(sNodeStructure);

		//return sNodeStructure as an xml node object
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		oXMLNodeElement = xslDoc.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(0);

		//get node value from node object
		if(oDOMNode){
			//oDOMNode = oCurrNode.cloneNode(true);
			return oDOMNode;
		}else{
			return null;
		}
	}


	function getRelNodeIndex_(iPNodeNdx, iCNodeNdx, iSetSize){
		//solution works only if the setSize is consitent with all parent nodes
		return ((iPNodeNdx * iSetSize) + iCNodeNdx);
	} 

	function getMaxNodeElementIndex_(sXQL){
		var oXMLNodeElement;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var iNodeNdx = -1;
		var i = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				iNodeNdx = iNodeNdx + 1;
			}
		}
		return iNodeNdx;		
	}

	function elementNodeCount_(sXQL){
		var oXMLNodeElement;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var iNodeNdx = 0;
		var i = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		try{
			oXMLNodeElement = this.oDOMGeneric_.documentElement;
			oNodeList = oXMLNodeElement.selectNodes(sXQL);
			iNodeListLen = oNodeList.length;

			for (i=0; i<iNodeListLen; i++){
				oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
				if (oChildNode.nodeType == this.NODE_ELEMENT_){
					iNodeNdx = iNodeNdx + 1;
				}
			}
			return iNodeNdx;
		}catch(err){
			return 0;
		}
	}

	function elementNodeCountByElement_(sXQL, sKeyName, sKeyValue){
		var oXMLNodeElement;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var iNodeCount = 0;
		var i = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				if (oChildNode.nodeName == sKeyName){
					if (oChildNode.hasChildNodes){
						if (oChildNode.childNodes.item(0).nodeTypedValue == sKeyValue){
							iNodeCount = iNodeCount + 1;
						}
					}else{
                        			if (oChildNode.text == sKeyValue){
                            				iNodeCount = iNodeCount + 1;
                        			}

					}
				}

			}
		}
		return iNodeCount;
	}




	function elementNodeCountByAttribute_(sXQL, sKeyName, sKeyValue){
		var oXMLNodeElement;
		var oAttribute;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var iNodeCount = 0;
		var iNodeNdx = -1;
		var i = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				iNodeNdx = iNodeNdx + 1;
				if (oChildNode.attributes.length > 0){
					oAttribute = oChildNode.attributes.getNamedItem(sKeyName);
					if (oAttribute){
						if (oAttribute.nodeTypedValue == sKeyValue){
							iNodeCount = iNodeCount + 1;
						}
					}
				}

			}
		}
		return iNodeCount;
	}
	
	function attributeNodeCount_(sXQL, iNodeNdx){
		var oXMLNodeElement;
		var oDOMNode;
		var iNodeAttributeLen = 0;
		
		iNodeNdx = iNodeNdx || 0;
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

		iNodeAttributeLen = oDOMNode.attributes.length;

		return iNodeAttributeLen;
	}

	function findNodeByElement_(sXQL, sKeyName, sKeyValue){
		var oXMLNodeElement;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var iNodeNdx = -1;
		var i = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				iNodeNdx = iNodeNdx + 1;
				if (oChildNode.nodeName == sKeyName){
					if (oChildNode.hasChildNodes){
						if (oChildNode.childNodes.item(0).nodeTypedValue == sKeyValue){
							return iNodeNdx;
						}
					}else{
                        			if (oChildNode.text == sKeyValue){
                            				return iNodeNdx;
                        			}

					}
				}

			}
		}
		return -1;		
	}


	function findNodeByAttribute_(sXQL, sKeyName, sKeyValue){
		var oXMLNodeElement;
		var oAttribute;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var iNodeNdx = -1;
		var i = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				iNodeNdx = iNodeNdx + 1;
				if (oChildNode.attributes.length > 0){
					oAttribute = oChildNode.attributes.getNamedItem(sKeyName);
					if (oAttribute){
						if (oAttribute.nodeTypedValue == sKeyValue){
							return iNodeNdx;
						}
					}
				}

			}
		}
		return -1;		
	}

	function findNodesByElement_(sXQL, sKeyName, sKeyValue){
		var oXMLNodeElement;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var oNodeNdxArray = new Array();
		var iNodeNdx = -1;
		var i = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				iNodeNdx = iNodeNdx + 1;
				if (oChildNode.nodeName == sKeyName){
					if (oChildNode.hasChildNodes){
						if (oChildNode.childNodes.item(0).nodeTypedValue == sKeyValue){
							oNodeNdxArray[oNodeNdxArray.length] = iNodeNdx;
						}
					}else{
                        			if (oChildNode.text == sKeyValue){
                            				oNodeNdxArray[oNodeNdxArray.length] = iNodeNdx;
                        			}

					}
				}

			}
		}

		if (oNodeNdxArray.length > 0){ 
			return oNodeNdxArray;
		}else{
			return false;
		}		


	}
	
	function findNodesByAttribute_(sXQL, sKeyName, sKeyValue, sFilterKeyName, sFilterKeyValue, boIsFilterTypeElement){
		sFilterKeyName = sFilterKeyName || "";
		sFilterKeyValue = sFilterKeyValue || "";
		boIsFilterTypeElement = boIsFilterTypeElement || false;
		
		var oXMLNodeElement;
		var oAttribute;
		var oFilterAttribute;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var oNodeNdxArray = new Array();
		var iNodeNdx = -1;
		var i = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				iNodeNdx = iNodeNdx + 1;
				if (oChildNode.attributes.length > 0){
					oAttribute = oChildNode.attributes.getNamedItem(sKeyName);
					if (oAttribute){
						if (oAttribute.nodeTypedValue == sKeyValue){
							if (sFilterKeyName != ""){
								oFilterAttribute = oChildNode.attributes.getNamedItem(sFilterKeyName);
								if (oFilterAttribute){
									if (oFilterAttribute.nodeTypedValue == sFilterKeyValue){
										oNodeNdxArray[oNodeNdxArray.length] = iNodeNdx;
									}
								}
							}else{
								oNodeNdxArray[oNodeNdxArray.length] = iNodeNdx;
							}
						}
					}
				}
			}
		}
		if (oNodeNdxArray.length > 0){
			return oNodeNdxArray;
		}else{
			return false;
		}
	}

	function findNodeByAttributes_(sXQL, sKeyName1, sKeyValue1, sKeyName2, sKeyValue2){
		var oXMLNodeElement;
		var oAttribute;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var iNodeNdx = -1;
		var i = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				iNodeNdx = iNodeNdx + 1;
				if (oChildNode.attributes.length > 0){
					oAttribute = oChildNode.attributes.getNamedItem(sKeyName1);
					if (oAttribute){
						if (oAttribute.nodeTypedValue == sKeyValue1){
							oAttribute = oChildNode.attributes.getNamedItem(sKeyName2);
							if (oAttribute){
								if (oAttribute.nodeTypedValue == sKeyValue2){
									return iNodeNdx;
								}
							}
						}
					}
				}

			}
		}
		return -1;		
	}


	
	function getSiblingValue_(sXQL,iNodeNdx,siblingTag){
  // sXQL is the Node Name u want the sibling for
  //  siblingTag is the tag name of the value u desired for	
 
		var oXMLNodeElement;
		var oDOMNode;
		var tagname;
		var childlen;
		var i;

		
		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		childlen = oXMLNodeElement.getElementsByTagName(sXQL).item(iNodeNdx).parentNode.childNodes.length;
		
		for(i=0;i<childlen;i++)
	           {
		 tagname = oXMLNodeElement.getElementsByTagName(sXQL).item(iNodeNdx).parentNode.childNodes.item(i).tagName;
					
		 if (tagname == siblingTag)	
		oDOMNode = oXMLNodeElement.getElementsByTagName(sXQL).item(iNodeNdx).parentNode.childNodes.item(i).nodeTypedValue;
		  }
			
		
		
		return oDOMNode;

		
	}

	function insertNode_(oNode, sNewNode, sXQLNewNode, sKeyName, sKeyValue, sNodePath){
	//insertNode insert a new node at element meeting search criteria and then returns pattern of the parent node that contains the new node

		var oChildNode;
		var currNdx = 0;
		var iPNodeNdx = 0;

		sNodePath = sNodePath || "";

		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		if (oNode){
			for (currNdx = 0; currNdx < oNode.childNodes.length; currNdx++) {
				//get a child node
				oChildNode = oNode.childNodes.item(currNdx);
			
				//check child node for attributes
				//alert(oChildNode.nodeName);    do something with element
				if (oChildNode.nodeType == this.NODE_ELEMENT_) { 
					if (oChildNode.attributes.length>0) {
						for  (m=0; m<oChildNode.attributes.length; m++){
							attrib = oChildNode.attributes.item(m);
							if (attrib.nodeName == sKeyName){
								if (attrib.nodeTypedValue == sKeyValue){
									oChildNode.appendChild (this.createNodeObject(sXQLNewNode, sNewNode));
									return "/" + oChildNode.nodeName;
								}
							}
						}			
					}
					
					//recurse if child node has children
					if (oChildNode.hasChildNodes) {
						sNodePath = this.insertNode(oChildNode, sNewNode, sXQLNewNode, sKeyName, sKeyValue, sNodePath);
				
						//if new node was inserted end recursion and  build the pattern location of the new node as we climb out of recursion
						if (sNodePath != ""){
							sNodePath  = "/" + oChildNode.nodeName + sNodePath;
							return sNodePath;
						}
					}	
				}	
			}
		}
		return sNodePath;
	}


	function getXQL_(oNode, sKeyName, sKeyValue, sNodePath){
	//insertNode insert a new node at element meeting search criteria and then returns pattern of the parent node that contains the new node

		var oChildNode;
		var currNdx = 0;
		var iPNodeNdx = 0;

		sNodePath = sNodePath || "";		//this parameter is used for recursion only

		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		if (oNode){
			for (currNdx = 0; currNdx < oNode.childNodes.length; currNdx++) {
				//get a child node
				oChildNode = oNode.childNodes.item(currNdx);
			
				//check child node for attributes
				//alert(oChildNode.nodeName);    do something with element
				if (oChildNode.nodeType == this.NODE_ELEMENT_) { 
					if (oChildNode.attributes.length>0) {
						for  (m=0; m<oChildNode.attributes.length; m++){
							attrib = oChildNode.attributes.item(m);
							if (attrib.nodeName == sKeyName){
								if (attrib.nodeTypedValue == sKeyValue){
									return "/" + oChildNode.nodeName;
								}
							}
						}			
					}
					
					//recurse if child node has children
					if (oChildNode.hasChildNodes) {
						sNodePath = this.getXQL(oChildNode, sKeyName, sKeyValue, sNodePath);
				
						//if new node was inserted end recursion and  build the pattern location of the new node as we climb out of recursion
						if (sNodePath != ""){
							sNodePath  = "/" + oChildNode.nodeName + sNodePath;
							return sNodePath;
						}
					}	
				}	
			}
		}
		return sNodePath;
	}



	function elementNodeCountByParentRef_(sXQL, sPRefName, sPRefValue, sPRefType, iPLevel){
		//Description: finds the number of childnodes belonging to its parent node with element or attribute value equal to sPRefValue
		var oXMLNodeElement;
		var oAttribute;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var iNodeNdx = -1;
		var i = 0;
		var sRef = "";
		var iRel = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		iPLevel = iPLevel || 3;

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				iNodeNdx = iNodeNdx + 1;
				if (iPLevel == 1){
					oAttribute = oChildNode.parentNode.attributes.getNamedItem(sPRefName);
				}else if (iPLevel == 2){
					oAttribute = oChildNode.parentNode.parentNode.attributes.getNamedItem(sPRefName);
				}else if (iPLevel == 3){
					oAttribute = oChildNode.parentNode.parentNode.parentNode.attributes.getNamedItem(sPRefName);
				}
				if (oAttribute){
					sRef = oAttribute.nodeTypedValue;
				}
				if (sPRefValue == sRef){
					iRel = iRel + 1;
				}
			}
		}
		return iRel;
	}

	function getParentNodeIndex_(sXQL, iNodeNdx, iPLevel){
		var oXMLNodeElement;
		var oDOMNode;

		iPLevel = iPLevel || 1;

		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oDOMNode = oXMLNodeElement.selectNodes(sXQL).item(iNodeNdx);

		//get node value from node object
		if(oDOMNode){
			return oDOMNode.nodeTypedValue;
		}else{
			return "";
		}		
	}


	function findNodeByParentRef_(sXQL, sPRefName, sPRefValue, sPRefType, iRelNodeNdx, iPLevel){
		var oXMLNodeElement;
		var oAttribute;
		var oNodeList;
		var oChildNode;
		var iNodeListLen = 0;
		var iNodeNdx = -1;
		var i = 0;
		var sRef = "";
		var iRel = -1;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}

		iPLevel = iPLevel || 3;

		oXMLNodeElement = this.oDOMGeneric_.documentElement;
		oNodeList = oXMLNodeElement.selectNodes(sXQL);
		iNodeListLen = oNodeList.length;

		for (i=0; i<iNodeListLen; i++){
			oChildNode = oXMLNodeElement.selectNodes(sXQL).item(i);
			if (oChildNode.nodeType == this.NODE_ELEMENT_){
				iNodeNdx = iNodeNdx + 1;
				if (iPLevel == 1){
					oAttribute = oChildNode.parentNode.attributes.getNamedItem(sPRefName);
				}else if (iPLevel == 2){
					oAttribute = oChildNode.parentNode.parentNode.attributes.getNamedItem(sPRefName);
				}else if (iPLevel == 3){
					oAttribute = oChildNode.parentNode.parentNode.parentNode.attributes.getNamedItem(sPRefName);
				}
				if (oAttribute){
					sRef = oAttribute.nodeTypedValue;
				}
				if (sPRefValue == sRef){
					iRel = iRel + 1;
					if (iRelNodeNdx == iRel){
						return i;
					}
				}
			}
		}
		return -1;
	}
	
	function getParentXPath_(sXPath){
		sXPath = sXPath || ""
		
		if (sXPath != ""){
			return sXPath.slice(0, sXPath.lastIndexOf("/"));
		}
	}
	
	function getChildNodeName_(sXPath){
		sXPath = sXPath || ""
		
		if (sXPath != ""){	
			return sXPath.slice(sXPath.lastIndexOf("/") + 1, sXPath.length);
		}
	}

	function validateNode_(sXPath, iNodeNdx){
		iNodeNdx = iNodeNdx || 0;
		
		iNodeCount = this.elementNodeCount(sXPath);
		if (iNodeCount > iNodeNdx || sXPath == ""){
			return true;
		}else{
			return false;
		}
	}
	
	function save_(sFilename, relative){
		var oFileSystem = new ActiveXObject("Scripting.FileSystemObject");
		var oXMLFile;
		var sXMLDocument;
		var sFilePath;

		if (relative){
			sFilePath = Server.Mappath(sFilename);
		}else{
			sFilePath = sFilename;
		}
		oXMLFile = oFileSystem.CreateTextFile(sFilePath, True);
		oXMLFile.WriteLine("This is a test.");
		oXMLFile.Close;
		
		return 1;
	}


	function removeAllNodeId_(oNode){
		var oChildNode;
		var oAttribute;
		var currNdx = 0;
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		if (oNode){
			for (currNdx = 0; currNdx < oNode.childNodes.length; currNdx++) {
				//get a child node
				oChildNode = oNode.childNodes.item(currNdx);
			
				//check child node for attributes
				if (oChildNode.nodeType == this.NODE_ELEMENT_) { 
					if (oChildNode.attributes.length>0) {
						for  (m=0; m<oChildNode.attributes.length; m++){
							oAttribute = oChildNode.attributes.item(m);
							if (oAttribute.nodeName == "_nid"){
								oChildNode.attributes.removeNamedItem ("_nid");
							}
						}			
					}
					
					//recurse if child node has children
					if (oChildNode.hasChildNodes) {
						this.removeAllNodeId(oChildNode);
					}	
				}	
			}
		}
	}

	function filterCdata_(oNode){
		var oChildNode;
		var currNdx = 0;
		var sCDataSection = "";
		
		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		if (oNode){
			for (currNdx = 0; currNdx < oNode.childNodes.length; currNdx++) {
				//get a child node
				oChildNode = oNode.childNodes.item(currNdx);	
				if (oChildNode.nodeType == this.NODE_CDATA_SECTION_ && oChildNode.parentNode.nodeName == "pre"){
					//filter cdata section of node
					sCDataSection = oChildNode.nodeTypedValue;
					re = /</gi;
					sCDataSection = sCDataSection.replace(re, "&lt;");
					re = />/gi;
					sCDataSection = sCDataSection.replace(re, "&gt;");
					oChildNode.text = sCDataSection;
				}				
				if (oChildNode.nodeType == this.NODE_ELEMENT_) {
					//recurse if child node has children
					if (oChildNode.hasChildNodes) {
						this.filterCdata(oChildNode);
					}	
				}	
			}
		}	
	}
	
	
	function filterTextStream_(sText){
		var newString, separator;

		if (!sText)
			newString = "";
		else
			try{
				newString = sText;
				
				separator = /&amp;#92;/gi;
				newString = newString.replace(separator, "\\");					
				separator = /&#60;/gi;
				newString = newString.replace(separator, "\<");
				separator = /&#62;/gi;
				newString = newString.replace(separator, "\>");		
				separator = /&#32;/gi;
				newString = newString.replace(separator, "\ ");	
				separator = /&#34;/gi;
				newString = newString.replace(separator, "\"");	
				separator = /&gt;/gi;
				newString = newString.replace(separator, "\>");	
				separator = /&lt;/gi;
				newString = newString.replace(separator, "\<");
			}
			catch(err){
				return sText;
			}								
		return newString;
	}

	function initNode_(oNode, sValue){
		var oChildNode;
		var currNdx = 0;
		var m = 0;

		//sXQL is a xsl query statement in the form of {/<element_name1>/<element_name2>}
		if (oNode){
			if (oNode.childNodes.length == 0){
				if (oNode.nodeType == this.NODE_TEXT_){
					oNode.text = sValue;
				}

				if (oNode.attributes.length>0) {
					for  (m=0; m<oNode.attributes.length; m++){
						attrib = oNode.attributes.item(m);
						attrib.text = sValue;
					}
				}
			}else{
				for (currNdx = 0; currNdx < oNode.childNodes.length; currNdx++) {
					//get a child node
					oChildNode = oNode.childNodes.item(currNdx);
				
					//check child node for attributes
					if (oChildNode.nodeType == this.NODE_TEXT_){
						oChildNode.text = sValue;
					}

					if (oChildNode.nodeType == this.NODE_ELEMENT_) { 
						if (oChildNode.attributes.length>0) {
							for  (m=0; m<oChildNode.attributes.length; m++){
								attrib = oChildNode.attributes.item(m);
								attrib.text = sValue;
							}			
						}
						
						//recurse if child node has children
						if (oChildNode.hasChildNodes) {
							this.initNode(oChildNode, sValue);
						}	
					}	
				}
			}
		}
	}
	
	function getNodeIndex_(oNode, sKeyname, sKeyvalue, sKeytype){
		var sXQL = "";

		sXQL = this.getXQL(oNode, sKeyname, sKeyvalue);
		if (sXQL != ""){
			return this.findNodeByAttribute(sXQL, sKeyname, sKeyvalue);
		}else{
			return -1;
		}
	}

	function sortOnAttribute_(oSourceDocument, sSourceXPath, sSourceElementName, sAttributeName, sNodeId, sSortDir, boIsPadding){
		var i;
		var j;
		var sSrcNodeId = "";
		var iNumElements;
		var iSortColNum;
		var objSortArray;
		var objListNode;
		var objListNodeArray;
	
		sAttributeName = sAttributeName || "";
		boIsInteger = boIsPadding || false;
		
		sNodeId = sNodeId || "";
		sSortDir = sSortDir || "ASC";

		iNumElements = oSourceDocument.elementNodeCount(sSourceXPath + "/" + sSourceElementName);
		iSortColNum = 0;

		objListNodeArray = this.createArray(iNumElements);

		if (iNumElements > 0){
			//define sort array
			objSortArray = this.createArray(iNumElements);

			//fill sort array
			for (i=0;i<iNumElements;i++){
				sSrcNodeId = oSourceDocument.readAttribute(sSourceXPath + "/" + sSourceElementName, sNodeId, i);
				var aNodeRec = new ANodeADT();
				aNodeRec.iRowNodeNdx = i;
				aNodeRec.iNodeNdx = oSourceDocument.findNodeByAttribute(sSourceXPath + "/" + sSourceElementName, sNodeId, sSrcNodeId);
				if (!boIsPadding){
					aNodeRec.sNodeText = oSourceDocument.readAttribute(sSourceXPath + "/" + sSourceElementName, sAttributeName, aNodeRec.iNodeNdx);
				}else{
					aNodeRec.sNodeText = oSourceDocument.readAttribute(sSourceXPath + "/" + sSourceElementName, sAttributeName, aNodeRec.iNodeNdx);					
					aNodeRec.sNodeText = this.padString(aNodeRec.sNodeText, "0", 10);
				}
				objSortArray[i] = aNodeRec;
			}
		}

		if (sSortDir == "ASC"){
			objSortArray.sort(this.sortCompareASC);
		}else if (sSortDir == "DSC"){
			objSortArray.sort(this.sortCompareDSC);
		}

		for (i=0;i<iNumElements;i++){
			objListNode = oSourceDocument.getXmlNode(sSourceXPath + "/" + sSourceElementName, objSortArray[i].iRowNodeNdx);
			objListNodeArray[i] = objListNode.xml;
		}

		for (i=(iNumElements-1);i>=0;i--){
			oSourceDocument.removeElement(sSourceXPath + "/" + sSourceElementName, i);
		}


		for (i=0;i<iNumElements;i++){
			oSourceDocument.appendXml(sSourceXPath, objListNodeArray[i], "/" + sSourceElementName, 0, true);
		}
		
		return oSourceDocument;
	}

	function padString_(strVar, strChar, intCount){
		var strPad = "";

		while (strVar.length < intCount){
			strVar = strChar + strVar;
		}
  		return strVar;
	}

	function dec2hex_(lngDecVal) {
    		var HexChars = '0123456789ABCDEF';
    		var HexStr = ''


        	while (lngDecVal>0){
        		var HexStr = HexChars.charAt( lngDecVal%16 ) + HexStr;
        		var lngDecVal = Math.floor(lngDecVal/16);
        	}
       		return HexStr
    }

	function createArray_(iArrayRowSize, iArrayColSize, iArrayType, iArrayDim){
		var objArray = false;
		var objArray2 = false;
		var i;

		iArrayColSize = iArrayColSize || 0;
		iArrayType = iArrayType || 0;
		iArrayDim = iArrayDim || 0;

		if (iArrayDim == 0){
			var objArray = new Array(iArrayRowSize);
			if (iArrayType == 0){
				for (i=0;i<objArray.length;i++){
					objArray[i] = "";
				}
			}
		}else if (iArrayDim == 1){
			var objArray = new Array(iArrayRowSize);
			if (iArrayType == 0){
				for (i=0;i<objArray.length;i++){
					var objArray2 = new Array(iArrayColSize);
					objArray[i] = objArray2;
				}
			}

			null;
		}
		return objArray;
	}


	function sortCompareDSC_(a,b){
		if(a.sNodeText > b.sNodeText){
			return -1;
		}else if (b.sNodeText > a.sNodeText){
			return 1;
		}else{
			return 0;
		}
	}

	function sortCompareASC_(a,b){

		if(a.sNodeText < b.sNodeText){
			return -1;
		}else if (b.sNodeText < a.sNodeText){
			return 1;
		}else{
			return 0;
		}
	}

	
} //end clsXMLAccess





function cDocAttachListType(){
	this.sId = "";
	this.sType = "";
	this.sData = "";
	this.sIsManualFile = "";
}


function adtRegisterControlItem(){
	this.sCategory = "";
	this.sName = "";
	this.fptrMethod = null;
}


function cDefaultQueueNode(){
	this.id = "";
	this.refid = "";
	this.item = "";
	this.source = "";
	this.ptrPrev = null;
	this.ptrNext = null;
}