//-------------------------------------------------------------------------
//    Declaration of constants
//-------------------------------------------------------------------------

//datatypes 

vbEmpty    = 0;
vbNull     = 1;
vbInteger  = 2;
vbLong     = 3;
vbSingle   = 4;
vbDouble   = 5;
vbCurrency = 6;
vbDate     = 7;
vbString   = 8;
vbObject   = 9;
vbError    = 10;
vbBoolean  = 11;
vbVariant  = 12;
vbDataObject = 13;
vbDecimal  = 14;
vbByte     = 17;
vbUserDefinedType = 36;
vbArray    = 8192;

//modification

vbNone        = 0; //undetermined
vbNotModified = 1;
vbModified    = 2;
vbNew         = 3;
vbNewModified = 4;
vbDelete      = 5;

//TypeName Array
var typename = new Array("Empty","Null","Integer","Long","Single","Double","Currency","Date","String",
"Object","Error","Boolean","Variant","Dataobject","Decimal","","","Byte");



// New Constants

mpNodeParameters = 0;
mpNodeValues = 1;
mpNodeDataElements = 2;
mpNodeSecureValues = 3;
mpNodeCDATAs = 4;
mpNodeErrors = 5;


mpNodeSchemas =0;
mpNodeRows = 1;

mpErrorAttrNumber=1;



//-------------------------------------------------------------------------
//    This is the object definition for an object to encapsulate
//    a new DOM
//-------------------------------------------------------------------------
function wfxDom ( as_xml_syntax ){
   this.domObj = new ActiveXObject("Microsoft.XMLDOM"); 
   this.domObj.async = false;
   
		if ( as_xml_syntax == null )
		{
			this.domObj.loadXML("<MethodPackage name='' return='-1' successful='False' object='' version='0.0.0'><parameters count='0'></parameters><values count='0'></values><data count='0' luw='0'></data><secure count='0'></secure><cdata count='0'></cdata><errors count='0'></errors></MethodPackage>");
		}
		else
		{
			this.domObj.loadXML( as_xml_syntax );
		}		
		
   this.addParam = __addParam;
   this.addValue = __addValue;
   this.addError = __addError;
   this.addDataElement = __addDataElement;
   this.addRow = __addRow;
   this.copySchema = __copySchema;
   this.copyRow = __copyRow;
   this.copyDataNode = __copyDataNode;
   this.copyNodeByName = __copyNodeByName;
   this.sendDataForm = __sendDataForm;
   this.setRowState = __setRowState;
   this.setColumnState = __setColumnState;
   this.sendDataHTTP = __sendDataHTTP;
   this.copySecure = __copySecure;
   this.setMPName = __setMPName;
   this.setMPReturn = __setMPReturn;
   this.getMPSuccessful = __getMPSuccessful;
   this.setMPSuccessful = __setMPSuccessful;
   this.setMPObject = __setMPObject;
   this.setMPVersion = __setMPVersion;
   this.setXML = __setXML;
   this.getDom = __getDom;
   this.getXML = __getXML;
   this.setDom = __setDom;
   this.getMPName = __getMPName;
   this.getMPReturn = __getMPReturn;
   this.getMPObject = __getMPObject;
   this.getMPVersion = __getMPVersion;
   this.getParameterCount = __getParameterCount;
   this.setParameter = __setParameter;
   this.deleteParameter = __deleteParameter;
   this.getParameter = __getParameter;
   this.getParameterVarType = __getParameterVarType;
   this.getParameterTypeName = __getParameterTypeName;
   this.getValueCount = __getValueCount;
   this.setValue = __setValue;
   this.deleteValue = __deleteValue;
   this.getValue = __getValue;
   this.getValueVarType = __getValueVarType;
   this.getValueTypeName = __getValueTypeName;
   this.getCDATACount = __getCDATACount;
   this.addCDATA = __addCDATA;
   this.setCDATA = __setCDATA;
   this.deleteCDATA = __deleteCDATA;
   this.getCDATA = __getCDATA;
   this.getErrorCount = __getErrorCount;
   this.getDataCount = __getDataCount;
   this.getLUW = __getLUW;
   this.setLUW = __setLUW; 
   this.getDataElementRowCount = __getDataElementRowCount;
   this.getDataElementName = __getDataElementName;
   this.getSchemaCount = __getSchemaCount;
   this.getUpdateableTable = __getUpdateableTable;
   this.setUpdateableTable = __setUpdateableTable;
   this.addSchemaColumn = __addSchemaColumn;
   this.getRowState = __getRowState;
   this.deleteRow = __deleteRow;
   this.addColumn = __addColumn;
   this.deleteColumn = __deleteColumn;
	this.getColumnValue = __getColumnValue;
	this.setColumnValue = __setColumnValue;
	this.getColumnOriginalValue = __getColumnOriginalValue;
	this.setColumnOriginalValue = __setColumnOriginalValue;
   this.getColumnState = __getColumnState;
   this.retrieveData = __retrieveData
   
   // New functions for async retrieval of data.
   this.retrieveDataAsync = __retrieveDataAsync;
   this.retrieveDataOnReadyStateChange = __retrieveDataAsyncOnReadyStateChange;
   this.retrieveDataAsyncCancel = __retrieveDataAsyncCancel;
  
   this.getRow = __getRow;
   this.getDataNode=__getDataNode;
   this.resyncDataRows = __resyncDataRows;
   this.getErrorNumber=__getErrorNumber;
   this.xml=__xml;
   
   
   
}
//-------------------------------------------------------------------------
//    This function will add a parameter to the MethodPackage XML
//    
//    Parameters:    ps_name          The name of the new Parameter
//                   ps_vartype       An integer indicating the datatype
//                                    of this parameter.  This number is 
//                                    is from a VB enumeration.
//                   
//                   p_value          The actual value to be placed within the tags. 
//
//        ***All Parameters are required****
//-------------------------------------------------------------------------
function __addParam (ps_name, pi_vartype, p_value) {
   paramNodeList = this.domObj.getElementsByTagName("parameters");
   paramNode = paramNodeList.item(0);
   paramNode.attributes.item(0).value++;
   newParameterNode = this.domObj.createNode(1, ps_name, "");
   parmelm = paramNode.insertBefore(newParameterNode, null);
   newParameterNode.setAttribute("vartype", pi_vartype);
   ls_typename = typename[pi_vartype];
   newParameterNode.setAttribute("typename", ls_typename);
   newParameterNode.text = p_value;
  
}  
//------------------------------------------------------------------------
//    Adds a node beneath the values node in the MethodPackage
//
//    Parameters:   ps_name            The name of the node to be added
//                  ps_vartype         An integer indicating the datatype
//                                     of this parameter.  This number is 
//                                     is from a VB enumeration.
//                  ps_typename        The name of this datatype.  ie. string,
//                                     long.
//                  p_value            The actual value to be placed within the tags.
//
//       ****All parameters are required****
//------------------------------------------------------------------------       
function __addValue(ps_name, pi_vartype, p_value) {
   valueNodeList = this.domObj.getElementsByTagName("values");
   valueNode = valueNodeList.item(0);
   valueNode.attributes.item(0).value++;
   newValueNode = this.domObj.createNode(1, ps_name, "");
   valueelm = valueNode.insertBefore(newValueNode, null);
   newValueNode.setAttribute("vartype", pi_vartype);
   ls_typename = typename[pi_vartype];
   newValueNode.setAttribute("typename", ls_typename);
   newValueNode.text = p_value;
}
//-------------------------------------------------------------------------
//   Adds an error node to MethodPackage
//
//   Parameters:     ps_number         The error number returned when the error
//                                     occurred.
//                   ps_description    The error description returned when the
//                                     error occurred.
//
//      ****All Parameters required****
//------------------------------------------------------------------------- 
function __addError( ps_number, ps_description, ps_severity, ps_type, ps_application, ps_object, ps_method, ps_linenum, ps_addmsg, ps_source )
{
	 var lobj_now;
	 
	 lobj_now = new Date();
   	
   errorNodeList = this.domObj.getElementsByTagName("errors");	
   errorNode = errorNodeList.item(0);
   errorNode.attributes.item(0).value++;
   newErrorNode = this.domObj.createNode(1, "error", "");
   errorelm = errorNode.insertBefore(newErrorNode, null);
   
   newErrorNode.setAttribute("id", "-1");
   newErrorNode.setAttribute("number", ps_number);
   newErrorNode.setAttribute("description", ps_description);
  
	 newErrorNode.setAttribute("severity", ps_severity);
	 newErrorNode.setAttribute("type", ps_type);
	
	 newErrorNode.setAttribute("application", ps_application);
	 newErrorNode.setAttribute("object", ps_object);
	 newErrorNode.setAttribute("method", ps_method);
	 newErrorNode.setAttribute("linenum", ps_linenum );
	 
 	 newErrorNode.setAttribute("addmsg", ps_addmsg);
 	 newErrorNode.setAttribute("source", ps_source );
 	 
 	 newErrorNode.setAttribute("time", lobj_now.toString() );
 	
 	 newErrorNode.setAttribute("sqlstate", "");
 	 newErrorNode.setAttribute("nativeerror", "0");
 	 newErrorNode.setAttribute("user_comments", "");
 	 newErrorNode.setAttribute("logged", "False");
 	
 	 lobj_now = null;
}
//------------------------------------------------------------------------
//    Adds a new, empty data element to the MethodPackage.  This function
//    is included as a way to create multiple recordsets in the MethodPackage.
//
//    Parameters:     p_name            The Name of the data element
//                    p_column_count    The number of columns in the new recordset.
//
//     ****Parameter is required
//-------------------------------------------------------------------------
function __addDataElement(p_name,p_column_count){
   dataNodeList = this.domObj.getElementsByTagName("data");
   dataNode = dataNodeList.item(0);
   dataNode.attributes.item(0).value++;
   newDataElementNode = this.domObj.createNode(1, p_name, "");   
   dataNode.appendChild(newDataElementNode);
   newDataElementNode.setAttribute("row_count", "0");
   newDataElementNode.setAttribute("column_count", p_column_count);
   return newDataElementNode;
}
//--------------------------------------------------------------------------
//    Copies the schema information for a recordset from the original MethodPackage
//    to the new dom. 
//
//    Parameters      p_fromDataElement     Name of the MethodPackage data element
//                                          to copy.
//                    p_toDataElement       Name of domObj data element to copy
//                                          the schema information to.
//   *****Parameters required******
//--------------------------------------------------------------------------
function __copySchema(p_fromDOM, p_fromDataElement, p_toDataElement){
   DEFNode = p_fromDOM.getElementsByTagName(p_fromDataElement).item(0);
   fromSchema = DEFNode.childNodes.item(0);
   DETNode = this.domObj.getElementsByTagName(p_toDataElement).item(0);   
   clonedSchema = fromSchema.cloneNode(1);
   DETNode.appendChild(clonedSchema);

}
//--------------------------------------------------------------------------
//    Copies a single row from the original MethodPackage to the new DOM.
//
//    Parameters:     p_rownum       The row number to copy(1 based).  If this
//                                   value isn't specified, the function attemps 
//                                   to get the current active row in the specified
//                                   DSO.  If no DSO is specified, the first row is
//                                   copied.
//                    p_dso          The Id of the DSO from which to copy the row. (MethodPackage)
//                    p_fromDataElement  The name of the data element being copied from (Required)
//                    p_toDataElement    The name of the data element being copied to (Required)
//
//   ****Parameters are optional, but see above for defaults****
//----------------------------------------------------------------------------
function __copyRow(p_rowNum, p_dso, p_fromDataElement, p_toDataElement) {
   //Determine if the dataelement exists, if not create it***********
   wfxDataElementList = this.domObj.getElementsByTagName(p_toDataElement);
   if (wfxDataElementList.length == 0) {
      MPDataElementList = p_dso.XMLDocument.getElementsByTagName(p_fromDataElement);
      MPDataElement = MPDataElementList.item(0);
      columnCount = MPDataElement.attributes.item(1).value;
      wfxDataElement = addDataElement(p_toDataElement, columnCount);
   }
   else {
      wfxDataElement = wfxDataElementList.item(0);
   }
   //If the schema does not exist, create it*********
   numSchemaNodes = wfxDataElement.childNodes.length;
   if (numSchemaNodes == 0 ) {
      copySchema(p_fromDataElement, p_toDataElement);
   }
   
   //Determine the row to copy
   if (p_rowNum > 0) {
      rownum = p_rowNum;
   }
   else {
      if (p_dso != null) {
         rownum = p_dso.recordset.AbsolutePosition;
      }
      else {
         rownum = 1;
      }
   }
   wfxRowsList = wfxDataElement.childNodes.length;
   if (wfxRowsList < 2) {
      newRowsNode = this.domObj.createNode(1, "rows", "");
      wfxDataElement.appendChild(newRowsNode);
      rowsNode = newRowsNode;
   } 
   else {
      rowsNode = wfxDataElement.childNodes.item(1);
   }
   //MPSourceRowList = MethodPackage.XMLDocument.getElementsByTagName("row");
   rownum--
   //MPSourceRow = MPSourceRowList.item(rownum);
   MPSourceRow = MPDataElement.childNodes.item(1).childNodes.item(rownum);
   clonedMPSourceRow = MPSourceRow.cloneNode(1);
   rowsNode.appendChild(clonedMPSourceRow);
   //alert(poo.domObj.xml);
   wfxDataElement.attributes.item(0).value++    
}
//----------------------------------------------------------------------------------
//    Copies an entire data node from the original MethodPackage to the new DOM.
//    Assumes one data node and that it is to be copied from the original MethodPackage
//    to the new DOM
//
//    ****No Parameters****
//-----------------------------------------------------------------------------------   
function __copyDataNode(p_fromDOM){
   wfxDataList = this.domObj.getElementsByTagName("data");
   wfxDataNode = wfxDataList.item(0);
   MPDataElementList = p_fromDOM.XMLDocument.getElementsByTagName("data_element");
   MPDataElementNode = MPDataElementList.item(0);
   cloneMPDataElementNode = MPDataElementNode.cloneNode(1);
   wfxDataNode.appendChild(cloneMPDataElementNode);
   wfxDataNode.attributes.item(0).value++;
   
}
//-------------------------------------------------------------------------------------
//   Copys a node from the MethodPackage to the new DOM.  You must specify the name
//   of the node to be copied and the parent beneath which it is to be placed.  The function
//   makes sure the nodes exist and that there is only one instance of the node name.
//
//   Parameters:       ps_nodeName       The name of the node to be copied.
//                     ps_parentNodeName The name of the parent node beneath which the
//                                       node is to be placed.
//
//          ****All Parameters are required****
//--------------------------------------------------------------------------------------
function __copyNodeByName(p_fromDOM, ps_nodeName, ps_parentNodeName) {
   MPNodeNameList = p_fromDOM.XMLDocument.getElementsByTagName(ps_nodeName);
   if (MPNodeNameList.length == 0) {
      alert("The node specified to copy does not exist!!");
      return
   }
   if (MPNodeNameList.length > 1) {
      alert("There are multiple nodes with the name "+ps_nodeName+"!!!");
      return
   }
   MPNamedNode = MPNodeNameList.item(0);
   clonedMPNamedNode = MPNamedNode.cloneNode(1);
   wfxNodeNameList = this.domObj.getElementsByTagName(ps_parentNodeName);
   if (wfxNodeNameList.length == 0) {
      alert("The node specified as the parent node does not exist!!");
      return
   }
   if (wfxNodeNameList.length > 1) {
      alert("There are multiple nodes with the name "+ps_parentNodeName+"!!!");
      return
   }
   wfxNamedNode = wfxNodeNameList.item(0);
   wfxNamedNode.appendChild(clonedMPNamedNode);
}
//--------------------------------------------------------------------------------------
//     Creates a hidden form on the page and sets its value to the XML string in this DOM
//     Parameters:     ps_method         Either GET or POST.  Defaults to POST.
//                     ps_action         The form's action.  Typically an asp page.
//   
//     ****Action is required, method is optional****
//---------------------------------------------------------------------------------------
function __sendDataForm ( ps_method, ps_action) {
   if (ps_method == "") { method = "POST";} else {method = ps_method;}
   if ( typeof ( wfxForm ) != "object" ) {
	formString = "<FORM NAME=wfxForm METHOD="+method+" ACTION="+ps_action+">" + "<INPUT TYPE=HIDDEN NAME=wfxText></FORM>";
	document.body.insertAdjacentHTML("beforeEnd",formString);
   } 
   else {
	wfxForm.method = ps_method;
	wfxForm.action = ps_action;
   }
   wfxForm.wfxText.value = this.domObj.xml;
   wfxForm.submit();
   
}
//---------------------------------------------------------------------------------------
//     Sends MethodPackage to the server using the XMLHTTP Object
//     Parameters:     p_url             The URL which will procedd the MethodPackage
//---------------------------------------------------------------------------------------
function __sendDataHTTP(p_url, ab_replaceXML){
   httpOb = new ActiveXObject("Microsoft.XMLHTTP");
   httpOb.Open("POST", p_url, false);
 
   httpOb.send(this.domObj.xml);
   
	 if (! ab_replaceXML) {
	 
      return httpOb.responseText;
	 
	 } else {
	 	
      this.domObj.loadXML(httpOb.responseText);
			
	 }		
 }
 
 function __retrieveDataAsync( as_URL, ab_replaceXML, af_proc_retrieved_data ) {
	this.httpObj = new ActiveXObject( "Microsoft.XMLHTTP" );
	this.httpObj.Open ( "POST", as_URL, true );
	this.httpObj.send( this.domObj.xml );
	this.httpObj.onreadystatechange = this.retrieveDataOnReadyStateChange( this, ab_replaceXML );
	
	this.procRetrievedData = af_proc_retrieved_data;
 }
 
 function __retrieveDataAsyncOnReadyStateChange( aobj_dom_client, ab_replaceXML ) {
	return function () {
		var lobj_tempDOM;
		
		if ( aobj_dom_client.httpObj.readyState == 4 ) {
			if (! ab_replaceXML ) {
				//Create a new DOM
				lobj_tempDOM = new ActiveXObject("Microsoft.XMLDOM");
						
				//Load the returned string into it
				lobj_tempDOM.loadXML( aobj_dom_client.httpObj.responseText );
			} else {
				aobj_dom_client.domObj.loadXML(aobj_dom_client.httpObj.responseText);
			}
			
			aobj_dom_client.procRetrievedData( lobj_tempDOM )
		}
	}
 }
 
 function __retrieveDataAsyncCancel() {
	if ( this.httpObj != null ) {
		this.httpObj.abort();
	}
 }

 function __retrieveData(as_URL, ab_replaceXML)
 {
	try
	{	
		if ( IncomingPageXML.xml.length > 0 ) 
		{ 
			var lobj_node = this.domObj.selectSingleNode( "//MethodPackage/secure/connstr" );
			
			if ( lobj_node == null )
			{
				throw( new Error( -1, "MethodPackage does not have a 'connstr' node." ) );
			}
			else if ( lobj_node.text.length < 1 )
			{
				throw( new Error( -1, "The 'connstr' value of the MethodPackage is blank." ) );
			}
			
		}
		//Create XMLHTTP object
		httpOb = new ActiveXObject("Microsoft.XMLHTTP");

		//open the object specifying the method, action and async properties
		httpOb.Open("POST", as_URL, false);

		//Send the contents of (string) of the customized dom
		httpOb.send(this.domObj.xml);

		//Receive the new string containing our data
		ls_dataXML = httpOb.responseText;

		if (! ab_replaceXML )
		{
			//Create a new DOM
			tempDOM = new ActiveXObject("Microsoft.XMLDOM");

			//Load the returned string into it
			tempDOM.loadXML( ls_dataXML );

			//Return the dom containing the data   
			return tempDOM
		} 
		else
		{
			this.domObj.loadXML(ls_dataXML);	
			return( ls_dataXML );	    	
		}				
			
	}   
	
	catch( lobj_ex )
	{
		HandleException( lobj_ex, true, "as_URL=" + as_URL, this.domObj.xml );	
		return( null );
	}
}

//----------------------------------------------------------------------------------------
//    Sets the modification state of a row
//    Parameters:      p_dataelement      The data element(recordset) containing the row
//                     ps_row             The row number to set state on
//                     ps_state           The state to assign the row
//----------------------------------------------------------------------------------------
function __setRowState(p_dataElement, ps_row, ps_state) {
	rowCollection = this.domObj.getElementsByTagName(p_dataElement).item(0).childNodes.item(1).childNodes;
	if (rowCollection.length == 0) {
		alert("No rows defined yet! Cannot set row state.");
	}
	rowCollection.item(ps_row).attributes.item(0).value = ps_state;	
}
//----------------------------------------------------------------------------------------
//    Sets the state of a column.  Use the constants defined above.
//    Parameters:      ps_row           The row containing the column to modify.
//                     ps_columnName    The name of the column to be modified
//                     ps_state         The state to set the column to.
//                     p_dataElement    The name of the dataElement containing the row and column
//
//   *****All Parameters Required*****
//----------------------------------------------------------------------------------------
function __setColumnState(ps_row, ps_columnName, ps_state, p_dataElement)
{
	rowCollection = this.domObj.getElementsByTagName(p_dataElement).item(0).childNodes.item(1).childNodes;
	if (rowCollection.length == 0)
	{
		alert ("No rows defined yet! Cannot set column state.");
	}
	sRow = rowCollection.item(ps_row);
  for (i=0;i<sRow.childNodes.length;i++)
  {
           if (sRow.childNodes.item(i).nodeName == ps_columnName) {
              sColumn = sRow.childNodes.item(i);
	      sColumn.attributes.item(1).value = ps_state;
           }
  }
} 
//------------------------------------------------------------------------------------------
//   Copies the secured section of the method package to this dom
//------------------------------------------------------------------------------------------
function __copySecure(p_fromDOM) {
	secureCollection = p_fromDOM.getElementsByTagName("secure");
        secureNode = secureCollection.item(0);
	      toSecureNode = this.domObj.getElementsByTagName("secure").item(0);
        for (j=0;j<secureNode.childNodes.length;j++){
           clonedNode = secureNode.childNodes.item(j).cloneNode(1);
           toSecureNode.appendChild(clonedNode); 
           toSecureNode.attributes.item(0).value++
        }  
}

function __setMPName(as_name) {
	 this.domObj.documentElement.attributes.item(0).value = as_name;
}
function __setMPReturn(ai_return) {
	 this.domObj.documentElement.attributes.item(1).value = ai_return;
}        
function __setMPSuccessful(ab_successful) {
	 this.domObj.documentElement.attributes.item(2).value = ab_successful;
}

function __getMPSuccessful() {
	return(  this.domObj.documentElement.attributes.item(2).value == "True" );
}

function __setMPObject(as_object) {
	 this.domObj.documentElement.attributes.item(3).value = as_object;
}
function __setMPVersion(as_version) {
 	this.domObj.documentElement.attributes.item(4).value = as_version; 	
}
function __setXML(as_XML) {
        this.domObj.loadXML(as_XML);
}

function __addRow(as_dataElementName, aobj_rowNode)
{
	var lobj_new_row;
	
	DENode = this.domObj.getElementsByTagName(as_dataElementName).item(0);
	
  if (DENode.childNodes.length == 0)
  {
		alert("Must copy schema information before adding row!");
		return( lobj_new_row );
  }
  
  if ( DENode.childNodes.length == 1 )
  {
     rowsNode = this.domObj.createElement("rows");
     DENode.appendChild( rowsNode);
     rowsNode.setAttribute( "dataid", as_dataElementName );
  }
  else
  {
		rowsNode = DENode.childNodes.item(1);
  }
  
  lobj_temp_dom = new ActiveXObject("Microsoft.XMLDOM");
  lobj_temp_dom.loadXML( aobj_rowNode.xml );
    
  lobj_new_row = rowsNode.appendChild( lobj_temp_dom.documentElement );
  DENode.attributes.item(0).value++;
  lobj_temp_dom = null;
  return( lobj_new_row );
}
//--------------------------------------------------------------------------------
//Returns a reference to the dom this object encapsulates
//--------------------------------------------------------------------------------
function __getDom() {
   
   return this.domObj;

}
//---------------------------------------------------------------------------------
//Returns the xml contained in this dom as a string.  If you pass the name of a node
// to this function, the XML for that node, only, will be returned
//---------------------------------------------------------------------------------
function __getXML (as_node) {

   if (as_node == null) {
   
      return this.domObj.xml;
   
   } else {
   
      lobj_nodeCol = this.domObj.documentElement.getElementsByTagName(as_node);      
      if (lobj_nodeCol.length <= 0) {
         return this.domObj.xml;
      } else {
         return lobj_nodeCol.item(0).xml;
      }
   }         
   
}
//----------------------------------------------------------------------------------
//Allows the user to assign the dom this object encapsulates
//----------------------------------------------------------------------------------
function __setDom(aobj_Dom) {

   this.domObj = aobj_Dom;
   
}         
//----------------------------------------------------------------------------------
//returns the value of the "name" attribute of the MethodPackage tag
//----------------------------------------------------------------------------------
function __getMPName() {

   return this.domObj.documentElement.attributes(0).value;
} 
//----------------------------------------------------------------------------------
//returns the value of the "return" attribute of the methodpackage tag
//----------------------------------------------------------------------------------
function __getMPReturn() {

   return this.domObj.documentElement.attributes(1).value;
   
}
//-----------------------------------------------------------------------------------
//sets the value of the "return" attribute of the methodpackage tag
//-----------------------------------------------------------------------------------
function __setMPReturn(ai_returnValue) {

   this.domObj.documentElement.attributes(1).value = ai_returnValue;
   
}    
//-----------------------------------------------------------------------------------
//returns the value of the "object" attribute of the methodpackage tag
//-----------------------------------------------------------------------------------
function __getMPObject() {

   return this.domObj.documentElement.attributes(3).value;
   
}   
//-----------------------------------------------------------------------------------
//sets the value of the "object" attribute of the methodpackage tag
//-----------------------------------------------------------------------------------
function __setMPObject(as_MPObject) {

   this.domObj.documentElement.attributes(3).value = as_MPObject;
   
}

//-----------------------------------------------------------------------------------
// returns the value of the "version" attribute of the methodpackage tag
//-----------------------------------------------------------------------------------
function __getMPVersion () {

   return this.domObj.documentElement.attributes(4).value;
   
}
//------------------------------------------------------------------------------------
// Sets the value of the "version" attribute of the methodpackage tag
//------------------------------------------------------------------------------------
function __setMPVersion (as_MPVersion) {

   this.domObj.documentElement.attributes(4).value = as_MPVersion;
   
}     
//------------------------------------------------------------------------------------
//returns the number of parameters in the methodpackage
//-------------------------------------------------------------------------------------
function __getParameterCount() {

   parmNode = this.domObj.documentElement.getElementsByTagName("parameters").item(0);
   return parmNode.attributes(0).value;
   
}    
//------------------------------------------------------------------------------------
//sets the value of a parameter already in the methodpackage
//------------------------------------------------------------------------------------
function __setParameter (as_param, as_value) {
   
   lobj_parmNode = this.domObj.documentElement.getElementsByTagName(as_param).item(0);
   
   lobj_parmNode.text = as_value;   
}
//------------------------------------------------------------------------------------
//deletes a parameter (removes the tag)
//------------------------------------------------------------------------------------
function __deleteParameter(as_param) {
   
   lobj_parmNode = this.domObj.documentElement.getElementsByTagName("parameters").item(0);
   
   for (i=0;i<this.lobj_parmNode.childNodes.length;i++) {
      
      if (this.lobj_parmNode.childNodes(i).nodeName == as_param) {
         this.lobj_parmNode.removeChild(this.lobj_parmNode.childNodes(i));
         this.lobj_parmNode.attributes(0).value --;
         break; 
      }
   }
}         
//------------------------------------------------------------------------------------
// returns the value of a parameter
//------------------------------------------------------------------------------------
function __getParameter(as_param) {

   this.lobj_parmNode = this.domObj.documentElement.getElementsByTagName("parameters").item(0);
   
   for (i=0;i<this.lobj_parmNode.childNodes.length;i++) {
      
      if (this.lobj_parmNode.childNodes(i).nodeName == as_param) {
         return this.lobj_parmNode.childNodes(i).text;
         break;
      }
   }
} 
//------------------------------------------------------------------------------------
// returns the vartype (int, see constants defined above) of a parameter
//------------------------------------------------------------------------------------
function __getParameterVarType(as_param) {

    this.lobj_parmNode = this.domObj.documentElement.getElementsByTagName("parameters").item(0);
   
   for (i=0;i<this.lobj_parmNode.childNodes.length;i++) {
      
      if (this.lobj_parmNode.childNodes(i).nodeName == as_param) {
         return this.lobj_parmNode.getAttribute("vartype");
         break;
      }
   }
} 
//------------------------------------------------------------------------------------
// returns the typename of a parameter
//------------------------------------------------------------------------------------
function __getParameterTypeName (as_param) {

   this.lobj_parmNode = this.domObj.documentElement.getElementsByTagName("parameters").item(0);
   
   for (i=0;i<this.lobj_parmNode.childNodes.length;i++) {
      
      if (this.lobj_parmNode.childNodes(i).nodeName == as_param) {
         return this.lobj_parmNode.getAttribute("typename");
         break;
      }
   }
} 
//------------------------------------------------------------------------------------
//returns the number of values in the methodpackage
//------------------------------------------------------------------------------------
function __getValueCount() {

   this.valNode = this.domObj.documentElement.getElementsByTagName("values").item(0);
   return this.valNode.attributes(0).value;
   
}  
//-------------------------------------------------------------------------------------
// Sets the data of a value tag which already exists
//------------------------------------------------------------------------------------
function __setValue(as_valueNode, as_value) {
   
   this.lobj_valNode = this.domObj.documentElement.getElementsByTagName(as_valueNode).item(0);
   
   this.lobj_valNode.text = as_value;   
}
//------------------------------------------------------------------------------------
// Deletes a value tag
//------------------------------------------------------------------------------------
function __deleteValue(as_value) {

   this.lobj_valNode = this.domObj.documentElement.getElementsByTagName("values").item(0);
   
   for (i=0;i<lobj_valNode.childNodes.length;i++) {
      
      if (lobj_valNode.childNodes(i).nodeName == as_value) {
         lobj_valNode.removeChild(lobj_valNode.childNodes(i));
         lobj_valNode.attributes(0).value --;
         break; 
      }
   }
}   
//------------------------------------------------------------------------------------
// returns the text of a value tag
//------------------------------------------------------------------------------------
function __getValue(as_value) {

   lobj_valNode = this.domObj.documentElement.getElementsByTagName("values").item(0);
   
   for (i=0;i<lobj_valNode.childNodes.length;i++) {
      
      if (lobj_valNode.childNodes(i).nodeName == as_value) {
         return lobj_valNode.childNodes(i).text;
         break;
      }
   }
} 
//------------------------------------------------------------------------------------
// returns the vartype (int, see constants defined above) of a value
//------------------------------------------------------------------------------------
function __getValueVarType (as_value) {

   lobj_valNode = this.domObj.documentElement.getElementsByTagName("values").item(0);
   
   for (i=0;i<lobj_valNode.childNodes.length;i++) {
      
      if (lobj_valNode.childNodes(i).nodeName == as_value) {
         return lobj_valNode.getAttribute("vartype");
         break;
      }
   }
} 
//------------------------------------------------------------------------------------
//returns the typename of a value
//------------------------------------------------------------------------------------
function __getValueTypeName(as_value) {

    lobj_valNode = this.domObj.documentElement.getElementsByTagName("values").item(0);
   
   for (i=0;i<lobj_valNode.childNodes.length;i++) {
      
      if (lobj_valNode.childNodes(i).nodeName == as_value) {
         return lobj_valNode.getAttribute("typename");
         break;
      }
   }
}
//------------------------------------------------------------------------------------
//returns the number of cdata sections
//------------------------------------------------------------------------------------
function  __getCDATACount() {

   cdatNode = this.domObj.documentElement.getElementsByTagName("cdata").item(0);
   return cdatNode.attributes(0).value;
   
}  
//-----------------------------------------------------------------------------------
//adds a cdata section
//-----------------------------------------------------------------------------------
function __addCDATA (as_name, as_value, as_type) {

   lobj_cdatNode = this.domObj.documentElement.getElementsByTagName("cdata").item(0);
   
   lobj_newNode = this.domObj.createNode(1, as_name, "");
   
   lobj_cdatNode.appendChild(lobj_newNode);
   
   lobj_cdatNode.attributes(0).value ++;
   
   lobj_newNode.setAttribute("type", as_type);
   
   lobj_newCdatNode = this.domObj.createCDATASection(as_value);
   
   lobj_newNode.insertBefore(lobj_newCdatNode, null);
   
}
//------------------------------------------------------------------------------------
//sets the value of an existing cdata section
//------------------------------------------------------------------------------------   
function __setCDATA(as_name, as_value, as_type) {

   lobj_cdatNode = this.domObj.documentElement.getElementsByTagName("cdata").item(0);
   
   for(i=0;i<lobj_cdatNode.childNodes.length;i++) {
   
      if (lobj_cdatNode.childNodes(i).nodeName == as_name) {
         
         lobj_cdatNode.childNodes(i).childNodes(0).text = as_value;
         lobj_cdatNode.childNodes(i).attributes(0).value = as_type;
         break;
      }
   }
}  
//---------------------------------------------------------------------------------
//deletes a cdata section (removes tag)
//---------------------------------------------------------------------------------
function __deleteCDATA(as_name) {    

   lobj_cdatNode = this.domObj.documentElement.getElementsByTagName("cdata").item(0);
   
   for(i=0;i<lobj_cdatNode.childNodes.length;i++) {
   
      if (lobj_cdatNode.childNodes(i).nodeName == as_name) {
         
         lobj_cdatNode.removeChild(lobj_cdatNode.childNodes(i));
         lobj_cdatNode.attributes(0).value --;
         break;
      }
   }
}       
//-----------------------------------------------------------------------------------
//returns the value of a cdata section
//-----------------------------------------------------------------------------------
function __getCDATA(as_name) {

   lobj_cdatNode = this.domObj.documentElement.getElementsByTagName("cdata").item(0);
   
   for(i=0;i<lobj_cdatNode.childNodes.length;i++) {
   
      if (lobj_cdatNode.childNodes(i).nodeName == as_name) {
         
         return lobj_cdatNode.childNodes(i).childNodes(0).text;
         break;
      }
   }
}   
//-------------------------------------------------------------------------------------
// returns the number of errors
//-------------------------------------------------------------------------------------
function __getErrorCount() {

   return this.domObj.documentElement.getElementsByTagName("errors").item(0).attributes(0).value;
}   
//-----------------------------------------------------------------------------------
// returns the number of data elements
//-----------------------------------------------------------------------------------
function __getDataCount() {
  
   lobj_datNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   return lobj_datNode.getAttribute("count");
} 
//-------------------------------------------------------------------------------------
// returns the value of the Logical Unit Of Work attribute
//-------------------------------------------------------------------------------------
function __getLUW() {

   lobj_datNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   return lobj_datNode.getAttribute("luw");
}   
//--------------------------------------------------------------------------------------
// sets the value of the logical unit of work attribute
//------------------------------------------------------------------------------------
function __setLUW(as_value) {

   lobj_datNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   lobj_datNode.setAttribute("luw", as_value);
}
//-----------------------------------------------------------------------------------
// returns the number of rows in a data element
//-----------------------------------------------------------------------------------
function __getDataElementRowCount(av_name_index) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   if (typeof av_name_index != "number") {
   
      for(i=0;i<lobj_dataNode.childNodes.length;i++) {
   
         if (lobj_dataNode.childNodes(i).nodeName == av_name_index) {
            return lobj_dataNode.childNodes(i).getAttribute("row_count");
            break;
         }
      }
      
   } else {
      if (av_name_index < lobj_dataNode.childNodes.length) { 
         return lobj_dataNode.childNodes(av_name_index).getAttribute("row_count");
      } else {
         alert("subscript out of range in getDataElementRowCount");
      }      
   }
}      

//-----------------------------------------------------------------------------------
//returns the number of columns in a data element
//-----------------------------------------------------------------------------------
function __getDataElementColumnCount(av_name_index) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   if (typeof av_name_index != "number") {
   
      for(i=0;i<lobj_dataNode.childNodes.length;i++) {
   
         if (lobj_dataNode.childNodes(i).nodeName == av_name_index) {
            return lobj_dataNode.childNodes(i).getAttribute("column_count");
            break;
         }
      }
      
   } else {
      if (av_name_index < lobj_dataNode.childNodes.length) { 
         return lobj_dataNode.childNodes(av_name_index).getAttribute("column_count");
      } else {
         alert("Subscript out of range in getDataElementRowCount"); 
      }      
   }
}      
//------------------------------------------------------------------------------------
// passed the index of a data element, returns its name
//------------------------------------------------------------------------------------
function __getDataElementName(ai_index) {
   
   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   if (ai_index < lobj_dataNode.childNodes.length) {
      return lobj_dataNode.childNodes(ai_index).nodeName;
   } else {
      alert("Index out of bounds in getDataElementName");
   }
}
//-------------------------------------------------------------------------------------
// passed either the index or name of a data element, returns the schema count attribute
//--------------------------------------------------------------------------------------
function __getSchemaCount(av_name_index) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   if (typeof av_name_index != "number") {
   
      for(i=0;i<lobj_dataNode.childNodes.length;i++) {
   
         if (lobj_dataNode.childNodes(i).nodeName == av_name_index) {
            return lobj_dataNode.childNodes(i).childNodes(0).getAttribute("count");
            break;
         }
      }
      
   } else {
      if (av_name_index < lobj_dataNode.childNodes.length) { 
         return lobj_dataNode.childNodes(av_name_index).childNodes(0).getAttribute("count");
      } else {
         alert("Subscript out of range in getSchemaCount"); 
      }      
   }
}     
//-------------------------------------------------------------------------------------
//passed either the index or the name of a data element, returns the value of its updateable table attribute
//-----------------------------------------------------------------------------------------
function __getUpdateableTable(av_name_index) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   if (typeof av_name_index != "number") {
   
      for(i=0;i<lobj_dataNode.childNodes.length;i++) {
   
         if (lobj_dataNode.childNodes(i).nodeName == av_name_index) {
            return lobj_dataNode.childNodes(i).childNodes(0).getAttribute("updtbl");
            break;
         }
      }
      
   } else {
      if (av_name_index < lobj_dataNode.childNodes.length) { 
         return lobj_dataNode.childNodes(av_name_index).childNodes(0).getAttribute("updtbl");
      } else {
         alert("Subscript out of range in getSchemaCount"); 
      }      
   }
}     
//------------------------------------------------------------------------------------
// passed eithe the name or the index for a data element, allows its updateable
// table attribute to be set
//------------------------------------------------------------------------------------               
function __setUpdateableTable(av_name_index, as_value) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   if (typeof av_name_index != "number") {
   
      for(i=0;i<lobj_dataNode.childNodes.length;i++) {
   
         if (lobj_dataNode.childNodes(i).nodeName == av_name_index) {
           lobj_dataNode.childNodes(i).childNodes(0).setAttribute("updtbl", as_value);
           break; 
         }
      }
      
   } else {
      if (av_name_index < lobj_dataNode.childNodes.length) { 
         lobj_dataNode.childNodes(av_name_index).childNodes(0).setAttribute("updtbl", as_value);
      } else {
         alert("Subscript out of range in getSchemaCount"); 
      }      
   }
}     
//-------------------------------------------------------------------------------------
// adds a column to the schema.  Data element specified by name
//-------------------------------------------------------------------------------------  
function __addSchemaColumn(as_dataElement, as_name, ai_attributes, ai_defined_size, ai_numeric_scale, ai_precision, ai_type, ai_updateable, as_key_column, ai_nullable, as_table_name, as_catalog_name, ai_vartype) {
   
   lobj_newNode = this.domObj.createNode(1, as_name, "");
   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
   
   for (i=0;i<lobj_dataNode.childNodes.length;i++) {  
   
      if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
      
         lobj_schemaNode = lobj_dataNode.childNodes(i).childNodes(0);
         
         
         lobj_schemaNode.appendChild(lobj_newNode);
         
         lobj_newNode.setAttribute("attributes", ai_attributes);
         lobj_newNode.setAttribute("defined_size", ai_defined_size);
         lobj_newNode.setAttribute("numeric_scale", ai_numeric_scale);
         lobj_newNode.setAttribute("precision", ai_precision);
         lobj_newNode.setAttribute("type", ai_type);
         lobj_newNode.setAttribute("updateable", ai_updateable);
         lobj_newNode.setAttribute("key_column", as_key_column);
         lobj_newNode.setAttribute("nullable", ai_nullable);
         lobj_newNode.setAttribute("table_name", as_table_name);
         lobj_newNode.setAttribute("catalog_name", as_catalog_name);
         lobj_newNode.setAttribute("vartype", ai_vartype);
         lobj_newNode.setAttribute("typename", typename[ai_vartype]);
         lobj_schemaNode.attributes(0).value++;
         lobj_dataNode.childNodes(i).attributes(1).value++;
         break;  
      }
   }
}         
//-----------------------------------------------------------------------------------
// returns the state of a certain row number in a data element (specified by name)
//-----------------------------------------------------------------------------------
function __getRowState(as_dataElement, ai_row) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
       
   for (i=0; i<lobj_dataNode.childNodes.length; i++) {
      if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
         lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
         break;
      }
   }
       
   return lobj_rowsNode.childNodes(ai_row).getAttribute("state");      
       
}
//-----------------------------------------------------------------------------------
// sets the value of a row's state attribute
//------------------------------------------------------------------------------------
function __setRowState(as_dataElement, ai_row, ai_state) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
       
   for (i=0; i<lobj_dataNode.childNodes.length; i++) {
      if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
         lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
         break;
      }
   }
       
    lobj_rowsNode.childNodes(ai_row).setAttribute("state", ai_state);      
       
}     
//------------------------------------------------------------------------------------
//deletes a certain row number from a specified data element
//-------------------------------------------------------------------------------------
function __deleteRow(as_dataElement, ai_row) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
       
   for (i=0; i<lobj_dataNode.childNodes.length; i++) {
      if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
         lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
         lobj_rowsNode.removeChild(lobj_rowsNode.childNodes(ai_row));
         lobj_dataNode.childNodes(i).attributes(0).value --;
         break;
      }
   }
 }
 //-------------------------------------------------------------------------------------
 //adds a column to each row in a dataelement.  Requires that the column already be 
 //added to the schema using "addSchemaColumn"
 //----------------------------------------------------------------------------------
 function __addColumn(as_dataElement, as_columnName) {
 
    lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
    
    for (i=0; i<lobj_dataNode.childNodes.length; i++) {
    
       if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
          
          lobj_schemaNode = lobj_dataNode.childNodes(i).childNodes(0);
          
          lb_schemaExists = false;
          
          for (j=0; j<lobj_schemaNode.childNodes.length; j++) {
             if (lobj_schemaNode.childNodes(j).nodeName == as_columnName) {
                lb_schemaExists = true;
             }
          }
          
          if ( ! lb_schemaExists) {
             alert("WARNING!  Must add column to schema before adding to rows");
             return -1;
          }         
          
          lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
          
          for (j=0; j<lobj_rowsNode.childNodes.length; j++) {
          
             lobj_rowNode = lobj_rowsNode.childNodes(j);
             
             lobj_newColumnNode = this.domObj.createNode(1, as_columnName, "");
             
             lobj_rowNode.appendChild(lobj_newColumnNode);
             
             lobj_newColumnNode.setAttribute("original_value", "");
             lobj_newColumnNode.setAttribute("state", vbNew);
             
             lobj_rowNode.setAttribute("state", vbModified);
             
          }
          break;
       }
    }
 }
 
 //-----------------------------------------------------------------------------
 // Deletes a column from all rows in a data element as from the schema associated
 // with it
 //-------------------------------------------------------------------------------
function __deleteColumn (as_dataElement, as_columnName) { 
 
   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
	 
	 for (i=0; i<lobj_dataNode.childNodes.length; i++) {
	 
	    if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
			
			   lobj_schemaNode = lobj_dataNode.childNodes(i).childNodes(0);
				 
				 for (j=0; j<lobj_schemaNode.childNodes.length; j++) {
				    if (lobj_schemaNode.childNodes(j).nodeName == as_columnName) {
						   lobj_schemaNode.removeChild(lobj_schemaNode.childNodes(j));
							 break;
						}
					}
					
					lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
					
					for (j=0; j<lobj_rowsNode.childNodes.length; j++) {
					
					   lobj_rowNode = lobj_rowsNode.childNodes(j);
						 
						 for (k=0; k<lobj_rowNode.childNodes.length; k++) {
						 
						    if (lobj_rowNode.childNodes(k).nodeName == as_columnName) {
								   lobj_rowNode.removeChild(lobj_rowNode.childNodes(k));
									 break;
								}
						}
				}
   	}
	}
}									 		 
	
function __getColumnValue(as_dataElement, ai_row, as_columnName) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
	 
	 for (i=0; i<lobj_dataNode.childNodes.length; i++) {
	    
			if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
			   lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
				 lobj_rowNode = lobj_rowsNode.childNodes(ai_row);
				 
				 for (j=0; j<lobj_rowNode.childNodes.length; j++) {
				    
						if (lobj_rowNode.childNodes(j).nodeName == as_columnName) {
						   return lobj_rowNode.childNodes(j).text;
						}
				}
		}
  }
}				

function __setColumnValue (as_dataElement, ai_row, as_columnName, as_value) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
	 
	 for (i=0; i<lobj_dataNode.childNodes.length; i++) {
	    
			if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
			   lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
				 lobj_rowNode = lobj_rowsNode.childNodes(ai_row);
				 
				 for (j=0; j<lobj_rowNode.childNodes.length; j++) {
				    
						if (lobj_rowNode.childNodes(j).nodeName == as_columnName) {
						   lobj_rowNode.childNodes(j).text = as_value;
						}
				}
		}
  }
}				
   		 
function __getColumnOriginalValue(as_dataElement, ai_row, as_columnName, as_value) {

   		lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
	 
	 for (i=0; i<lobj_dataNode.childNodes.length; i++) {
	    
			if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
			   lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
				 lobj_rowNode = lobj_rowsNode.childNodes(ai_row);
				 
				 for (j=0; j<lobj_rowNode.childNodes.length; j++) {
				    
						if (lobj_rowNode.childNodes(j).nodeName == as_columnName) {
						   return lobj_rowNode.childNodes(j).getAttribute("original_value");
						}
				}
		}
  }
}						 			 
	
function __setColumnOriginalValue(as_dataElement, ai_row, as_columnName, as_value) {

   lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
	 
	 for (i=0; i<lobj_dataNode.childNodes.length; i++) {
	    
			if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
			   lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
				 lobj_rowNode = lobj_rowsNode.childNodes(ai_row);
				 
				 for (j=0; j<lobj_rowNode.childNodes.length; j++) {
				    
						if (lobj_rowNode.childNodes(j).nodeName == as_columnName) {
						   lobj_rowNode.childNodes(j).setAttribute("original_value", as_value);
						}
				}
		}
  }
}					 
             
function __getColumnState(as_dataElement, ai_row, as_columnName) {

      lobj_dataNode = this.domObj.documentElement.getElementsByTagName("data").item(0);
	 
	 for (i=0; i<lobj_dataNode.childNodes.length; i++) {
	    
			alert(lobj_dataNode.childNodes(i).nodeName)
			
			if (lobj_dataNode.childNodes(i).nodeName == as_dataElement) {
			   lobj_rowsNode = lobj_dataNode.childNodes(i).childNodes(1);
				 lobj_rowNode = lobj_rowsNode.childNodes(ai_row);
				 
				 for (j=0; j<lobj_rowNode.childNodes.length; j++) {
				    
						if (lobj_rowNode.childNodes(j).nodeName == as_columnName) {
						   return lobj_rowNode.childNodes(j).getAttribute("state");
						}
				}
		}
  }
}					 


      
function __getRow(as_dataElementName,al_row)
{
	var RowNode;
	
	DENode =this.getDataNode(as_dataElementName);
	
    DERowsList = DENode.childNodes(mpNodeRows).childNodes;
	
	
	if (DERowsList.length < al_row) {
      alert("Row index("+al_row+") is out of ranged!!!!");
      return;
    }
	
	RowNode=DERowsList.item(al_row - 1);
	
	
	return RowNode;
}  

function __getDataNode(as_dataElementName)
{
	DENodeList =this.domObj.documentElement.childNodes(mpNodeDataElements).getElementsByTagName(as_dataElementName);
	if (DENodeList.length == 0) {
      alert("The node("+as_dataElementName+") does not exist!!");
      return
	}
    if (DENodeList.length > 1) {
      alert("There are multiple nodes with the name "+as_dataElementName+"!!!");
      return;
    }
    return (DENodeList.item(0));

}


function __resyncDataRows(as_dataElementName,aobj_dsosrv)
{
	var DERowsNode;
	var NewRowsNodes;
	var lobj_wfx_dom;
	
	DENode = this.getDataNode(as_dataElementName);
	lobj_wfx_dom = new wfxDom(aobj_dsosrv.mobj_xml_root.xml);
    DERowsNode = DENode.childNodes(mpNodeRows);
    NewRowsNodes=lobj_wfx_dom.domObj.documentElement;
    
    DENodeList(0).replaceChild(NewRowsNodes,DERowsNode);
    
}


function __getErrorNumber(al_row)
{
	var lobjErrRow;
	
	
	lobjErrRow =this.domObj.documentElement.childNodes(mpNodeErrors).childNodes(al_row);
    return (lobjErrRow.attributes(mpErrorAttrNumber).value)
}

function __xml()
{
	return (this.domObj.xml)
}