/**************************************************
FEFramework
自由精灵脚本框架
版本1.0
包含以下文件:
		FEFrameworkBasic.js
---------------------------
	待定:
**************************************************/
/**************************************************
FEFrameworkBasic.js
自由精灵脚本框架基本js，提供基础脚本及框架基类
**************************************************/
/*###################################
框架基类
###################################*/
function FEFrameworkBasic(paraObj)
{
/*
###addvice
将来必要时，私有变量尽量变成属性
addvice###
*/

	var _this = this ;
	this.addXSL = _addXSL ;
	this.getXSL = _getXSL ;
	this.transform = _transform ;
	this.addUI = _addUI ;
	this.createUIObj = _createUIObj ;
	this.getUIObjByKey = _getUIObjByKey ;
	this.getUIObjById = _getUIObjById ;
	this.getUIObjListById = _getUIObjListById ;
	this.removeUIObj = _removeUIObj ;
	this.getUIUsability = _getUIUsability ;
	this.getTopDivExistability = _getTopDivExistability ;
	this.getElementByGloablScrollbar = _getElementByGloablScrollbar ;
	this.showHint = _showHint ;
	this.closeHint = _closeHint ;
	this.UIObjAjaxSend = _UIObjAjaxSend ;
	this.addDeBugMsg = _addDeBugMsg ;
	this.setDebugMode = _setDebugMode ;
	this.useOneDlog = _useOneDlog ;
	this.getXMLHandler = _getXMLHandler ;
	this.getOtherHandler = _getOtherHandler ;
	this.getDOMHandler = _getDOMHandler ;
	this.getAjaxHandler = _getAjaxHandler ;
	
	var _DOMHandler ;
	var _AjaxHandler ;
	var _OtherHandler ;
	var _XMLHandler ;
	var _HintObj ;
	
	var _XSLPool ;
	var _UIPool ;
	var _UIObjPool ;
	
	var _UIDOMUrlBase ;
	var _UIJsUrlBase ;
	
	var _topDivObj ;
	
	var _debugMode;
	main( paraObj ) ;
	function main( paraObj )
	{
		//alert( _getOtherHandler());
		_OtherHandler = new FEOtherHandler(_this) ;
		_DOMHandler = new FEDOMHandler(_this) ;
		_AjaxHandler = new FEAjaxHandler(_this) ;
		_XMLHandler = new FEXMLHandler(_this) ;
//XSL池
		_XSLPool = _OtherHandler.getDictionary() ;
//元件池
		_UIPool = _OtherHandler.getDictionary() ;
//元件实例池
		_UIObjPool = _OtherHandler.getDictionary() ;
//Hint对象
		_HintObj = new FEHint( null , _this , "-1" ) ;
		
//开始接收参数

		_UIDOMUrlBase = _OtherHandler.getObjAttribute( paraObj , "UIDOMUrlBase" , "UIDOM/" ) ;
		//alert();
		_UIJsUrlBase = _OtherHandler.getObjAttribute( paraObj , "UIJsUrlBase" , "UIJs/" ) ;
		
		var topDivObjId = _OtherHandler.getObjAttribute( paraObj , "topDivObjId" , null ) ;
//如果指定了该外层DIV的id之参数,则寻找这个DIV.这个DIV通常为了在IE6下实现FIX效果
		if( topDivObjId != null )
		{
			_topDivObj = document.getElementById( topDivObjId ) ;
		}
		if( _topDivObj != null )
		{
//初始化模拟FIX效果的准备工作
			var y = "100%" ;
			
//即设置_topDivObj的纵向滚动条
			with( _topDivObj.style )
			{
				height = y ;
				overflowY = "auto" ;
			}
//并隐藏body的纵滚动条,以取代body自己的滚动条
/*
###cross-browser
//应加上判断,如果是IE7或FF,则无需如此,容后作
cross-browser###
*/			
			with( document.body.style )
			{
				marginRight = 0 ;
				marginTop = 0 ;
				marginBottom = 0 ;
				overflowY = "hidden" ;
			}
		}
//提取地址栏中的调试标志的TAG,默认格式为?FEDebug=1
		var locationDebugModeTag = _OtherHandler.getObjAttribute( paraObj , "FEDebugTag" , "FEDebug" ) ;

		if( locationDebugModeTag.trim() != "" )
		{
//从地址栏?后面的信息中,提取是否为调试状态
			var locationDebugModeValue = "" ;
			var s = window.location.search ;
			s = "&" + s.replace( /^\?+/gi , "" ) + "&" ;
			if( (new RegExp( "\\&" + locationDebugModeTag + "=([^\\&]*)\\&" , "gi" )).test( s ) )
			{
				locationDebugModeValue = RegExp.$1 ;
			}
			_debugMode = false;
			if( locationDebugModeValue.trim() != "" )
			{
				_debugMode = true;
				_setDebugMode( true ) ;
			}
		}		
	}
	
	function _addXSL( _key , _url , _xsldata , _overwrite , _callbackfunc )
	{
//向"转换规则池"中根据文件路径增加一个XSL转换规则,此方法支持异步回调
/*
参数_key是该转换规则在"转换规则池"中的键值,实际上,这个池是由字典实现的
参数_url是XSL所在的文件
参数_xsldata是xsl字符串,如果为地址申请的方式,请置为null
参数_overwrite指明,如果该键值的规则已经存在,是否替换
_callbackfunc是回调函数指针,如果指明该参数,则将采用异步的方式加载XSL样式文件,并用此函数回调.否则将采用同步的方式加载XSL文件
###addvice
将来必要时，addXSL等方法放到相应的池对象
addvice###
*/
//开始获取参数,如果未指定,则赋默认值。如果需要指定默认值则统一设置内部变量，如果不需要则直接使用形参。
		var key = _OtherHandler.getVar( _key , null ) ;
		var url = _OtherHandler.getVar( _url , null ) ;
		var xsldata = _OtherHandler.getVar( _xsldata , null ) ;
		var overwrite = _OtherHandler.getVar( _overwrite , false ) ;
		var callbackfunc = _OtherHandler.getVar( _callbackfunc , null ) ;
		
		var xslDoc = _XMLHandler.getXMLDOM();
		var xslStr = "" ;
/*
###addvice
类似下面的判断语句可以优化一下
addvice###
*/
//如果直接指定了XSL数据或将其指定为函数，则执行action
		if( xsldata != null && ( ( ( typeof xsldata ) == "string" && xsldata.trim() != "" ) || ( typeof xsldata ) == "function" ) )
		{
			return action( xslStr , 200 );
		}
//否则采用地址读取XSL文件
		else
		{
//如果地址也为空
			if( url == null || url.trim() == "" )
			{
				return action( null , -1 );
			}
//地址不为空则进行ajax申请,并指定action作为回调函数
			else
			{
/*
###pending work
所有_AjaxHandler.send方法实现需要修改，根据类的方法
pending work###
*/
				_AjaxHandler.send( "" , url , action ) ;
				return xslDoc ;
			}
		}

//action为内部方法，为要执行的核心动作
		function action( _str , _state )
		{
//如果发生错误
			if( _state != 200 || _str == null || ( ( typeof _str ) == "string" &&  _str.trim() == "" ) )
			{
				xslDoc = null ;
			}
//如果一切正常
			else
			{
//如果是XSL字符串,则解析,如果是函数,则不进行此操作
				if( ( typeof _str ) == "string" )
				{
					xslDoc.loadXML( _str ) ;
				}
//装入池。如果不存在或参数为覆盖则Add，否则直接赋值
				if( !_XSLPool.Exists( key ) || overwrite )
				{
					_XSLPool.Add( key , xslDoc ) ;
				}
				else
				{
					_XSLPool.Item( key ) = xslDoc ;
				}
			}
//进行回调
			if( ( typeof callbackfunc ) == "function" )
			{
				callbackfunc( xslDoc )
			}
//返回xslDoc
			return xslDoc ;
		}
	}
	
	function _getXSL( _key )
	{
//判断此键是否在池中存在,如果存在,返回相应的对象
		if( _XSLPool.Exists( _key ) )
		{
			return _XSLPool.Item( _key ) ;
		}
//否则返回空
		return null ;
	}
	
	function _transform( _data , _key , _para )
	{
/*
//根据"转换规则池"中的对应规则,将指定的XML数据转换成HTML代码
//_data为需要转换的XML数据,可以为XML对象,也可以是XML格式的字符串
###addvice
_type为类型参数，将来除了xml转html，还将提供其它形式的转换
addvice###
*/
		var xmlDoc;
//如果找不到xsl则返回null
		if( !_XSLPool.Exists( _key ) )
		{
			return null ;
		}
//如果是XML字符串
		if( ( typeof _data ) == "string" )
		{
			xmlDoc= _XMLHandler.getXMLDOM()
			xmlDoc.loadXML( _data );			
		}
//如果是XML对象
		else
		{
			xmlDoc = _data ;
		}
//取得XSL对象		
		var xslObj = _XSLPool.Item( _key ) ;
//如果XSL对象其实为一个函数
		if( ( typeof xslObj ) == "function" )
		{
			return 	xslObj( xmlDoc , _para ) ;
		}
//转换并返回
		return xmlDoc.transformNode( xslObj ) ;
	}
	
	function _addUI( _id, _callbackfunc )
	{
/*
将UI控件的元件注册到元件池中.
元件包含DOM对象和与之绑定的JS类
参数_id:元件实体部分的DOM中的id
参数_callbackfunc:用于回调的函数指针
###advice
将来若借鉴.net等结构模式，系统控件和用户控件应分出分别处理
将来有可能实现元件可脚本操作编辑，以实现类似动态整体变换，则此处返回对UI的引用
advice###
*/
//如果_id参数有误,即失败,回调null
		if( ( typeof _id != "string" ) && ( typeof _id != "object" ) )
		{
			actionEnd( null ) ;
			return ;
		}
		if( ( typeof _id == "string" ) && _id.trim() == "" )
		{
			actionEnd( null ) ;
			return ;
		}
		if( ( typeof _id ) == "object" && ( typeof _id.tagName ) == "undefined" )
		{
			actionEnd( null ) ;
			return ;
		}
//如果已存在的_id,回调相应的id
		if( _UIPool.Exists( _id) )
		{
			actionEnd( _id) ;
			return ;
		}

		var DOMObj = null ;
		if( ( typeof _id ) == "string" )
		{
			DOMObj = document.getElementById( _id) ;
		}
		else if( ( typeof _id ) == "object" && ( typeof _id.tagName ) != "undefined" )
		{
			DOMObj = _id ;
			if( DOMObj.getAttribute( "UIObjKey" ) == null )
			{
				DOMObj.setAttribute( "UIObjKey" , "FEUIKey_" + _OtherHandler.getUndefinedName() + "_" + _OtherHandler.getPrefixStr( parseInt( Math.random() * 1000 ), 3 ) ) ;
			}
			_id = DOMObj.getAttribute( "UIObjKey" ) ;
		}
		
		
		var className = null ;
		var UIClass = null ;
//如果DOM对象没有直接存在于BODY中
		if( DOMObj == null )
		{
			_AjaxHandler.send( "" , _UIDOMUrlBase + _id+ ".htm" , action ) ;
		}
//如果DOM对象已经存在于BODY中
		else
		{
			action3();
		}
		
//action为内部函数，核心动作，动态获取元件的实体部分HTML代码
		function action( _str , _state )
		{
//如果读取失败,即失败,回调null
			if( !( _state == 200 || _state == 0 ) || _str.trim() == "" )
			{
				actionEnd( null ) ;
				return ;
			}
			//解析HTML代码并得到首元素
			var newObj = _DOMHandler.parseHTML( _str ) ;
			
			if( newObj == null )
			{
				actionEnd( null ) ;
				return ;
			}
			DOMObj = newObj ;
			
			action3();
		}
		
//action3为内部函数，核心动作，获取元件的类部分
		function action3()
		{
			className = DOMObj.getAttribute( "UIClassName" ) ;
/*
//如果没有设该属性,或者设置无效,即失败,回调null
###advice
此处应加扩展性处理,即给一个默认的UI类供绑定,待实现
advice###
*/
			if( className == null || className.trim() == "" )
			{
				actionEnd( null ) ;
				return ;
			}
			try
			{
				UIClass = eval( className ) ;
			}catch( e ){ UIClass = null }
//如果该类定义已经出现在页面中,转入下一步
			if( ( typeof UIClass ) == "function" )
			{
				action5() ;
			}
//否则进行动态申请
			else
			{
				_AjaxHandler.send( "" , _UIJsUrlBase + className + ".js" , action4 ) ;			
			}
		}

//action4为内部函数，核心动作，动态获取元件的类部分JS代码
		function action4( _str , _state )
		{
//如果读取失败
			if( !( _state == 200 || _state == 0 ) || _str.trim() == "" )
			{
				actionEnd( null ) ;
				return ;
			}
			var headObj=( document.documentElement.getElementsByTagName( "HEAD" )[0] )
			var scriptObj = document.createElement( "SCRIPT" ) ;
			scriptObj.language = "javascript" ;
			scriptObj.type = "text/javascript" ;
			scriptObj.defer = true;
			scriptObj.text = _str ;
//将类定义在页面中执行一次
			headObj.appendChild( scriptObj ) ;

/*
###cross-browser
FF下要用script.text实现
cross-browser###
			//var scriptCode = "&nbsp;<span><scr"+ "ipt language=\"javascript\" type=\"text/javascript\" defer=\"true\">" ;
			//scriptCode += _str ;
			//scriptCode += "</scr" + "ipt></span>" ;//FF下要用script.text实现,由WMT改进
			//document.body.insertAdjacentHTML( "beforeEnd" , scriptCode ) ;//将类定义在页面中执行一次
*/
//担心IE的一些BUG,加此延迟以消除
			setTimeout( action4_call , 1 ) ;
		}
		
		function action4_call( _str , _state )
		{
			try
			{
				UIClass = eval( className ) ;
			}catch( e ){ UIClass = null }
//如果仍未取得正确的类定义,即失败,回调null义
			if( ( typeof UIClass ) != "function" )
			{
				actionEnd( null ) ;
				return ;
			}
//如果成功,转入下一步			
			action5() ;
		}
		
//action5为内部函数，核心动作，将元件的实体部分和类部分的信息保存起来,并保存其它信息
		function action5()
		{
//根据onlyOne类型的不同,要作不同的处理
			var UI = new Object();
			UI.id = _id;
			UI.DOMObj = DOMObj ;
			UI.UIClass = UIClass ;

			UI.onlyOne = _OtherHandler.parseBool( _OtherHandler.getObjAttribute( DOMObj , "onlyOne" , "false" ) ) ;
//用于onlyOne类型
			UI.UIObj = null ;
//用于非onlyOne类型
			UI.UIObjIdColl = "" ;
//置入池			
			_UIPool.Add( _id, UI ) ;
//成功,回调id	
			actionEnd( _id)
		}
		
//actionEnd为内部函数，核心动作，统一进行回调处理,如果失败,id为null
		function actionEnd( id )
		{
			if( ( typeof _callbackfunc ) == "function" )
			{
				_callbackfunc( id ) ;
			}
		}
	}
	
	function _createUIObj( _id, _callbackfunc )
	{
/*
创建指定元件的实例.
值得注意的是,元件分为是否onlyOne两种类型.
如果是onlyOne类型,则创建时直接引用相映的DOM对象,而非创建.并且会自动检查该元件的实例是否已经创建,如果是,则不再重复创建.
如果元件在元件池中不存中,则将自动调用registUIOriginal方法,进行创建.
创建的UI对象将注册到UI对象池中
参数_id:元件实体部分的DOM中的id
参数_p_callbackfuncFunc:用于回调的函数指针
*/
//如果该元件已注册进入元件池
		if( _UIPool.Exists( _id) )
		{
			actionEnd( _id);
		}
//否则,进行注册工作
		else
		{
			_addUI( _id, actionEnd );
		}
		

//actionEnd为内部函数，核心动作
		function actionEnd( _id)
		{
//如果未注册过,并且注册失败.则失败,并回调null
			if( _id== null )
			{
				_callbackfunc( null ) ;
				return ;
			}
//提取元件信息
			var UI = _UIPool.Item( _id) ;
			var DOMObj = UI.DOMObj ;
			var UIClass = UI.UIClass ;
			var newObj = null ;
/*
###advice
最好createFlag改名
advice###
*/
//生成池中的新id
			var newId = "FEUIObj"
			newId += "_" + _OtherHandler.getUndefinedName() ;
			newId += "_" + _OtherHandler.getPrefixStr( parseInt( Math.random() * 1000 ), 3 ) ;
			var createFlag = false ;
//如果是onlyOne类型,并且已经存在实例
			if( UI.onlyOne && UI.UIObj != null )
			{
				newObj = UI.UIObj ;
			}
//否则,创建实例
			else
			{
				var tempDomObj = DOMObj ;
				if( !UI.onlyOne )
				{
					tempDomObj = DOMObj.cloneNode( true )
				}
				newObj = new UIClass( tempDomObj , _this , newId ) ;
				createFlag = true ;
				tempDomObj = null ;
			}
			
//如果实例是新创建的,则加入到池,并作后续处理
			if( createFlag )
			{
/*
###advice
这里最好再在_UIObjPool中验证一下,该KEY是否已经存在,或者用循环的方式去加随机数
advice###
*/

//加入到池
				_UIObjPool.Add( newId , newObj ) ;
//如果是onlyOne类型,则在元件对象中记录该实例的引用
				if( UI.onlyOne )
				{
					UI.UIObj = newObj ;
				}
//如果不是,则将这个元件的id记录到元件的UIObjIdColl中
				else
				{
					UI.UIObjIdColl += "," + newId ;
					UI.UIObjIdColl = UI.UIObjIdColl.replace( /(^,+)|(,+$)/gi , "" ) ;
				}
			}
			
			if( ( typeof _callbackfunc ) == "function" )
			{
//成功,回调
				_callbackfunc( newObj ) ;
			}
		}
	}
	
	function _getUIObjByKey( _key )
	{
/*
根据key从UI对象池中得到UI对象
参数_key:实例的key
*/
//如果存在
		if( _UIObjPool.Exists( _key ) )
		{
			return _UIObjPool.Item( _key )
		}
//否则返回null		
		return null ;
	}
	
	function _getUIObjById( _id, _callbackfunc )
	{
/*
根据id去取UI对象.
如果是onlyOne类型的对象,则直接返回其引用;反之则创建新的实例
如果没有创建,则创建之
*/
		if( _UIPool.Exists( _id) )
		{
/*
###advice
			//其实本段代码在_createUIObj中也有实现.这里再封装一次,是为了效率.这样作可好?
			//如果此步没有必要,则该考虑本函数是否有必要.
			//但对于开发人员来说,如果只有createUIObj,似乎容易引起歧义

advice###
*/
			var UI = _UIPool.Item( _id) ;
//判断指定id的元件是否onlyOne类型,如果是,则直接回调
			if( UI.onlyOne && UI.UIObj != null )
			{
				actionEnd( UI.UIObj ) ;
				return ;
			}
		}
//否则,进行创建的工作
		_createUIObj( _id, _callbackfunc ) ;
		
		function actionEnd( obj )
		{
			if( ( typeof _callbackfunc ) == "function" )
			{
				//回调
				_callbackfunc( newObj ) ;
			}
		}
	}
	
	function _getUIObjListById( _id)
	{
/*
根据元件id取得所有实例
*/
/*
###advice
//应该返回0长度的数组
advice###
*/
//如果不存在的id
		var result = new Array() ;
		if( !_UIPool.Exists( _id ) )
		{
			return result ;
		}
//初始化结果数组
		var result = new Array() ;
//得到元件
		var UI = _UIPool.Item( _id ) ;

//如果是onlyOne类型,直接返回唯一的实例.前提是假如进行了实例化
		if( UI.onlyOne )
		{
			if( UI.UIObj != null )
			{
				 result[ result.length ] = UI.UIObj ;
			}
		}
//如果不是onlyOne类型,则根据记录返回多个实例.前提是假如进行了实例化
		else
		{
			if( UI.UIObjIdColl != "" )
			{
				var list = UI.UIObjIdColl.split( "," ) ;
				for( var i = 0 ; i < list.length ; i++ )
				{
					var obj = _getUIObjByKey( list[ i ] ) ;
					if( obj != null )
					{
						//逐一加入到结果中去
						 result[ result.length ] = obj ;
					}
				}
			}
		}
	}
	
	function _removeUIObj( _key , _id , _flag )
	{
/*
根据实例的KEY删除元件的实例
或根据元件的id删除onlyOne类型的元件的实例.
参数_key:实例的key
参数_id:onlyOne类型元件的实例
*/
//得到key
		var key = _OtherHandler.getVar( _key , null ) ;
//得到id
		var id = _OtherHandler.getVar( _id, null ) ;
//如果key和id都不正确,即发生异常,退出
		if( key == null && id == null )
		{
			return false ;	
		}
		var UI ;
		var UIObj ;

//如果以key的形式删除.这通常是非onlyOne元件
		if( key != null )
		{
//得到UI实例	
			UIObj = _UIObjPool.Item( key ) ;
			if( UIObj == null || ( typeof UIObj.getUIId ) != "function" )
			{
//发生异常,退出
				return false ;	
			}
			if( !_UIPool.Exists( UIObj.getUIId() ) )
			{
//发生异常,退出
				return false ;	
			}
//得到UI元件
			UI = _UIPool.Item( UIObj.getUIId() ) ;
		}
//如果以id的形式删除.这通常是非onlyOne元件
		else
		{
			if( !_UIPool.Exists( id ) )
			{
//发生异常,退出
				return false ;	
			}
//得到UI元件
			UI = _UIPool.Item( id ) ;
//使用这种方式,必须是onlyOne类型的元件
			if( !UI.onlyOne )
			{
				return false ;
			}
//如果没有实例化或发生异常,退出
			if( UI.UIObj == null || ( typeof UI.UIObj.getUIObjKey ) != "function" )
			{
				return false ;
			}

//得到实例的key
			key = UI.UIObj.getUIObjKey() ;
//得到UI实例	
			UIObj = UI.UIObj ;
		}
		
		if( ( typeof UIObj.end ) == "function" )
		{
//实例的结束工作
			UIObj.end( _flag ) ;
		}
//从实例池中移除
		_UIObjPool.Remove( key ) ;
//如果是onlyeOne类型
		if( UI.onlyOne )
		{
			UI.UIObj = null ;
		}
//如果是非onlyeOne类型
		else
		{
			var idColl = "," + UI.UIObjIdColl + "," ;
			idColl = idColl.replace( "," + key + "," , "," ) ;
			idColl = idColl.replace( /(^,+)|(,+$)/gi , "" ) ;
			UI.UIObjIdColl = idColl ;
		}
	}
	
	function _getUIUsability( _id )
	{
/*
得到某元件是否可用.
如果是onlyOne类型的元件,则如果其唯一的实例正在使用,即返回不可用;反之返回可用
如果不是onlyOne类型的元件,则恒可用.
*/
		if( !_UIPool.Exists( UIObj.getUIId() ) )
		{
//发生异常,退出
			return false ;	
		}
//得到元件
		var UI = _UIPool.Item( _id) ;
//如果非onlyOne类型的元件,恒可用
		if( !UI.onlyOne )
		{
			return true ;	
		}
//如果onlyOne类型的元件尚未实例化,可用
		if( UI.UIObj == null )
		{
			return true ;	
		}
//如果实例声明自己正在使用中,则不可用
		if( ( typeof UI.UIObj.getUsingFlag ) == "function" && !UI.UIObj.getUsingFlag() )
		{
			return false ;	
		}
//其它情况,可用
		return true ;
	}
	
	function _getTopDivExistability()
	{
/*
得到是否因为FIX效果,而在BODY下加了一个外层的DIV.
*/
		if( _topDivObj == null )
		{
			return false ;	
		}
		return true ;
	}
	
	function _getElementByGloablScrollbar()
	{
//获取全局滚动条对象
		if( _getTopDivExistability() )
		{
			return _topDivObj ;
		}
		return document.body ;
	}
	
	function _showHint( _s , _obj , _t , pos )
	{
/*
在鼠标位置或指定对象的位置,用一个DIV显示指定的信息
参数_s: 用于显示的信息的字符串
参数_obj:指定的显示位置的对象,如果不指定此参数,则将在鼠标的附近显示信息
参数_t:隔多长时间消失.默认是3秒
*/
		_HintObj.showHint( _s , _obj , _t , pos ) ;
	}
	
	function _closeHint()
	{
/*
关闭Alert的信息
*/
		_HintObj.closeHint() ;
	}
		
	function _getXMLHandler()
	{
		return _XMLHandler ;
	}
	function _getOtherHandler()
	{
		//alert(12);
		return _OtherHandler ;
	}
	function _getDOMHandler()
	{
		return _DOMHandler ;
	}
	function _getAjaxHandler()
	{
		return _AjaxHandler ;
	}

	function _UIObjAjaxSend( _requestObj , _sendStr , _baseUrlKey , _url , _para , _flag )
	{
		_AjaxHandler.send( _sendStr , _baseUrlKey , _url , actionEnd , _para , _flag )
		function actionEnd( _str , _state , para , newKey )
		{
			if( ( typeof _requestObj.AjaxTransaction ) == "function" )
			{
				_requestObj.AjaxTransaction( _str , _state , para , newKey ) ;
			}
			
		}
	}
	
	function _setDebugMode( _f )
	{
		_debugMode = _f ;
		popDebugWindow() ;
	}

	function _useOneDlog( _dlogKey , _key , _callbackFunc , _title , _x , _y , _onSuccess , _onCancel )
	{
		var dlogKey = _getOtherHandler().getVar( _dlogKey , null ) ;
		if( dlogKey == null )
		{
			return ;	
		}
		_createUIObj( dlogKey , action2 ) ;
	
		function action2( obj )
		{
			if( obj == null )
			{
				return ;
			}
			if( typeof obj.loadContent == "function" )
			{
				obj.loadContent( _key , _callbackFunc , _title , _x , _y , _onSuccess , _onCancel ) ;
			}
		}
	}

	function _addDeBugMsg( _s , _t )
	{
/*
供开发人员调试的时候使用
_s:用以显示的信息
_t:类型.如果为1,则提示为”发送消息”,如果为0,则提示为”接收消息”
*/
		if( !_debugMode || _debugObj == null )
		{
			return ;
		}
		
		try
		{
			_debugObj.innerHTML += "<br/>*********"
			if( _t == 0 )
			{
				_debugObj.innerHTML += FEG.getTextByLanguage( "takeMessage" )
			}
			else
			{
				_debugObj.innerHTML += FEG.getTextByLanguage( "sendMessage" )
			}
			_debugObj.innerHTML += "*******" + (new Date()).toString(); + "*****"
			_debugObj.innerHTML += "******<br/><br/> "
			_debugObj.innerText += " \n " + _s ;
			_debugObj.innerHTML += "<br/>############### END ###############<br/>"
		}catch(e){}
	}
	
	function popDebugWindow()
	{
/*
打开调试窗口
*/
		if( _debug && _debugObj == null )
		{
/*唯一于此函数中初始化的DOM对象*/
			var debugwindow = window.open( "about:blank" , "ElvenChatTest" ) ;
			try
			{
				debugwindow.document.write( "<html><title>debug Window</title><body></body></html>" ) ;
				debugwindow.document.close() ;
				
				_debugObj = debugwindow.document.body ;
			}catch(e){}
		}
	}
}