// JavaScript Document
function FEXMLHandler(_root,paraObj)
{
	var _this = this ;
	var root = _root ;
	this.getXMLRoot = function ( varXML )
	{
		/*从varXML中提取XMLDOC中的documentElement*/
		/*其中varXML可以是XML格式的字符串*/
		/*也可以是个XML对象,也可以是XML的documentElement.如果是这两种情况,则返回的是对相关对象的引用,而非复制*/
		var xmlOjb = null ;
		if( ( typeof varXML ) == "string" )
		{
			xmlOjb = getXMLDOM() ;
			xmlOjb.loadXML( varXML ) ;
		}
		else if( ( typeof varXML ) == "object" )
		{
			xmlOjb = varXML ;
		}
		if( xmlOjb != null )
		{
			if( typeof xmlOjb.documentElement != "undefined" )
			{
				try
				{
					if( xmlOjb.parseError.errorCode == 0 )
					{//判断XML格式是否正确,如果不正确,则返回null
						return xmlOjb.documentElement ;
					}
					return null ;
				}catch(e)
				{
					return 	xmlOjb ;
				}
			}
			else
			{
				return 	xmlOjb ;
			}
		}
		return null ;	
	}

	this.getXmlChildNode = function ( varXML , nodeName )
	{
		var root = this.getXMLRoot( varXML ) ;
		if( root == null )
		{
			return null ;	
		}
		
		return root.selectSingleNode(nodeName);
	}

	this.getXmlNode = function ( varXML , nodeName )
	{
		/*从the中提取XMLDOC根结点下指定结点名的节点*/
		/*如果有若干个相同节点名的节点,则将采用第一个*/
		/*varXML是相关的XML数据,nodeName是节点名*/
		/*其中varXML可以是XML格式的字符串*/
		/*也可以是个XML对象,也可以是XML的documentElement.如果是这两种情况,则返回的是对相关对象的引用,而非复制*/
		/*如果varXML格式有误,或找不到该节点,则返回null*/
		var root = this.getXMLRoot( varXML ) ;
		if( root == null )
		{
			return null ;	
		}
		
		if( root.getElementsByTagName( nodeName ).length == 0 )
		{
			return null ;
		}
		else
		{
			return ( root.getElementsByTagName( nodeName )[ 0 ] );
		}
	}

	this.getXmlNodeText = function ( varXML , nodeName )
	{
		/*从varXML中提取XMLDOC根结点下指定结点名的节点文本*/
		/*varXML是相关的XML数据,nodeName是节点名*/
		/*如果有若干个相同节点名的节点,则将采用第一个*/
		/*其中varXML可以是XML格式的字符串*/
		/*也可以是个XML对象,也可以是XML的documentElement.如果是这两种情况,则返回的是对相关对象的引用,而非复制*/
		/*如果varXML格式有误,或找不到该节点,则返回null*/
		var root = this.getXMLRoot( varXML ) ;
		if( root == null )
		{
			return null ;	
		}
		nodeName = typeof nodeName != "undefined" ? nodeName : null ;
		if( nodeName == null )
		{
			return 	root.text ;
		}
		if ( root.getElementsByTagName( nodeName ).length == 0 )
		{
			return null ;
		}
		else
		{
			return ( root.getElementsByTagName( nodeName )[ 0 ].text );
		}
	}

	this.getXmlNodeAttribute = function ( varXML , nodeName , attributeName )
	{
		/*从varXML中提取XMLDOC根结点下指定结点名的节点中的指定属性名的属性值*/
		/*varXML是相关的XML数据,nodeName是节点名,attributeName是属性名*/
		/*如果有若干个相同节点名的节点,则将采用第一个*/
		/*其中varXML可以是XML格式的字符串*/
		/*也可以是个XML对象,也可以是XML的documentElement.如果是这两种情况,则返回的是对相关对象的引用,而非复制*/
		/*如果varXML格式有误,或找不到该节点,或找不到该属性,则返回null*/
		var root = this.getXMLRoot( varXML ) ;
		if( root == null ){ return null ; }
		
		if ( root.getElementsByTagName( nodeName ).length == 0 )
		{
			return null ;
		}
		else
		{
			return ( root.getElementsByTagName( nodeName )[ 0 ].getAttribute( attributeName ) );
		}
	}

	this.getAttribute = function ( varXML , attributeName )
	{
		/*从varXML中提取XMLDOC根结点下指定结点名的节点中的指定属性名的属性值*/
		/*varXML是相关的XML数据,nodeName是节点名,attributeName是属性名*/
		/*如果有若干个相同节点名的节点,则将采用第一个*/
		/*其中varXML可以是XML格式的字符串*/
		/*也可以是个XML对象,也可以是XML的documentElement.如果是这两种情况,则返回的是对相关对象的引用,而非复制*/
		/*如果varXML格式有误,或找不到该节点,或找不到该属性,则返回null*/
		var root = this.getXMLRoot( varXML ) ;
		if( root == null ){ return null ; }
		return root.getAttribute( attributeName );
	}

	this.addXmlNode = function ( theElement , n , t , _overwrite )
	{
		/*向指定的XML节点添加子节点*/
		/*theElement是指定的节点,n是节点名,t是指定的节点文本.如果不指定t或将t指定为null,则将自动把文本置为空*/
		/*如果未指定n,或n为null,或n为空字符串,将添加失败*/
		/*如果添加成功,将返回新添加的节点引用;如果失败,该返回null*/

		var overwrite = typeof _overwrite == "boolean" ? _overwrite : false ;
		var theText = "" ;
		if( ( typeof n ) == "undefined" || t == null || n.trim() == "" )
		{
			return null ;
		}
		if( ( typeof t ) != "undefined" && t != null )
		{
			theText = t ;
		}
		var xmlDoc,nodeElement ;
		var xmlDoc = getXMLDOM() ;
		if( overwrite )
		{
			var obj = this.getXmlNode( theElement , n ) ;
			if( obj != null )
			{
				theElement.removeChild( obj ) ;
			}
		}
		
		var nodeElement = xmlDoc.createElement( n )
		nodeElement.text = theText
		theElement.appendChild(nodeElement)	
		return nodeElement ;	
	}
	
	
	this.getXmlNodeChilds = function ( varXML , nodeName )
	{
		/*从the中提取XMLDOC根结点下指定结点名的节点下的所有子结点,并以数组的形式返回*/
		/*varXML是相关的XML数据,nodeName是节点名*/
		/*如果有若干个相同节点名的节点,则将采用第一个*/
		/*其中varXML可以是XML格式的字符串*/
		/*也可以是个XML对象,也可以是XML的documentElement.如果是这两种情况,则返回的是对相关对象的引用,而非复制*/
		/*如果varXML格式有误,或找不到该节点,则返回null*/
		var root = this.getXMLRoot( varXML ) ;
	
		if( root == null ){ return null ; }
		
		if ( root.getElementsByTagName( nodeName ).length == 0 )
		{
			return null ;
		}
		else
		{
			return ( root.getElementsByTagName( nodeName )[ 0 ].childNodes );
		}
	}
	
	this.getXmlNodeOuterXML = function ( varXML , nodeName )
	{
		/*从the中提取XMLDOC根结点下指定结点名的节点的XML代码*/
		/*varXML是相关的XML数据,nodeName是节点名*/
		/*如果有若干个相同节点名的节点,则将采用第一个*/
		/*其中varXML可以是XML格式的字符串*/
		/*也可以是个XML对象,也可以是XML的documentElement.如果是这两种情况,则返回的是对相关对象的引用,而非复制*/
		/*如果varXML格式有误,或找不到该节点,则返回null*/
		var root = this.getXMLRoot( varXML ) ;
		if( root == null ){ return null ; }
		
		if ( root.getElementsByTagName( nodeName ).length == 0 )
		{
			return null ;
		}
		else
		{
			return ( root.getElementsByTagName( nodeName )[ 0 ].xml );
		}
	}
	
	this.getXmlNodesByName = function ( varXML , nodeName )
	{
		/*从the中提取XMLDOC根结点下指定结点名的若干个节点,并以数组的形式返回,如果找不到该节点,则将返回0长度的数组*/
		/*如果varXML格式有误,则返回null*/
		var root = this.getXMLRoot( varXML ) ;
		if( root == null ){ return null ; }
		
		return root.getElementsByTagName( nodeName )
	}

	this.mergeXML = function ( a , _b )
	{
		/*合并两个XMLDoc对象,注意,不能是XMLDoc.documentElement对象*/
		/*合并的过程中,将以a的根结点为根结点,把_b的所有子节点全部插回到a中来*/
		/*函数没有返回值,对象a中内容将直接被改变*/
		var b = this.getXMLDOM() ;
		b.loadXML( _b.xml )
		var a1 , b1 ;
		if( b.documentElement == null )
		{
			return ;	
		}
		b1 = b.documentElement.childNodes ;
		if( a.documentElement == null )
		{
			a.loadXML( "<" + b.documentElement.tagName + "/>" ) ;
		}
		a1 = a.documentElement ;
		for( var i = 0 ; i < b1.length ; i++ )
		{
			a1.appendChild( b1.item(i--) ) ;
		}
	}

	this.getXMLDOM = getXMLDOM ;
	function getXMLDOM()
	{
		/*得到一个新建的XMLDOC对象,此方法将自动适应各种浏览器*/
		/*待改造,以适应IE7和FF*/
		var the = null ;
		try
		{
			the = new ActiveXObject("Msxml2.DOMDocument.5.0");
		}catch(e)
		{
			try
			{
				the = new ActiveXObject("Msxml2.DOMDocument.4.0");
			}catch(e)
			{
				try
				{
					the = new ActiveXObject("Msxml2.DOMDocument.3.0");
				}catch(e)
				{
					try
					{
						the = new ActiveXObject("Msxml.DOMDocument");
					}catch(e){}
				}		
			}
		}		
		return the ;
	}
	this.xmlNodeToObj = function xmlNodeToObj( xmlNode , initObj )
	{
		if( ( typeof xmlNode ) == "string" )
		{
			xmlNode = this.getXMLRoot( xmlNode ) ;
		}
		if( xmlNode == null )
		{
			return null ;	
		}
		var formatFlag = false ;
		var theObj ;
		if( ( typeof initObj ) == "object" )
		{//如果指明的转换格式的对象
			theObj = initObj ;
			formatFlag = true ;
		}
		else
		{
			theObj = new Array() ;
		}
		
		for( var i = 0 ; i < xmlNode.attributes.length ; i++ )
		{
			var _current = xmlNode.attributes[ i ] ;
			var _f = true ;
			if( formatFlag && ( typeof theObj[ _current.name ] ) == "undefined" )
			{
				_f = false ;
			}
			if( _f )
			{
				theObj[ _current.name ] = _current.value ;
			}
		}
		
		/*临时写法*/
		if( ( typeof theObj[ "id" ] ) != "undefined" && ( typeof theObj[ "ID" ] ) == "undefined" )
		{
			theObj[ "ID" ] = theObj[ "id" ] ;
		}
		
		return 	theObj ;
	}

	this.ObjToxmlNode = function ObjToxmlNode( initObj , _rootTag )
	{
		var rootTag = "root" ;
		if( ( typeof _rootTag ) != "undefined" )
		{
			rootTag = _rootTag
		}
		var the = getXMLDOM() ;
		the.loadXML( "<" + rootTag + "/>" ) ;
		var _root = this.getXMLRoot( the ) ;
		for( var i in initObj )
		{
			_root.setAttribute( i , initObj[ i ] ) ;
		}
		return _root ;
	} 
}