/*
 * 代号：凤凰
 * 创建日期 2007-02-10
 * V2.0
 * JavaScript 调用后台方法
 * 马宝刚
 */
 var ACTION_EXT_NAME = ".ha"; //动作扩展名
 var DEBUG_MODE = "debug"; //标识为调试默认参数值
 var SCRIPT_INNER_TAG = "___script"; //在内部标签信息中，需要执行javascript内容 的标签
 var ATTRIBUTE_CHECK_TYPE = "checktype"; //提交数据时校验标签值类型 属性名
 var ATTRIBUTE_FIX_TYPE = "fixtype"; //处理值属性
 
 //常用方法
 //getFormDataUrl(action,formNodeOrId);
 //popupaction(thisTagOrId,url,title, width, height, formNodeOrId, showBar);
 //showModalDialogHTML(thisTagOrId,url,param, width, height, fullScreen);
 //popupHTML(thisTagOrId,url,title, width, height, showBar, fullScreen);
 //sendDataReturnText(thisTagOrId, url, formNodeOrId, innerTagNodeOrId, doMethod, methodPara, debugTag, setValueMode, noReturnValue, isSync, urlToForm, sendData, noError);
 //getNodeByNeighborhood(tagOrId,attributeName,attributeValue);
 //checkScriptFromInnerTag(innerTagOrId);
 //getNodeElementsByNodeName(nodeOrId,nodeName);
 //getNodeById(id);
 //getNodeAttribute(node,attribName);
 //getNodeName(node);
 //getFormData(submitForm,res,needCheck);
 //getNodeByObject(nodeOrId);
 //getNodeIdByObject(nodeOrId);
 //getNodeElementById(nodeOrId,idValue);
 //getElementsInDocumentByAttribute(attributeName,attributeValue);
 //getElementsInNodeByAttribute(nodeOrId,attributeName,attributeValue);
 //getElementInNodeByAttribute(nodeOrId,attributeName,attributeValue);
 //getElementSubmitPara(elem,needCheck);
 //checkTagValue(tagOrId,checkValue,checkType);
 //getSid();
 //moveNode(thisNodeOrId,type);
 //insertNode(thisNodeOrId,newNode,type,isParentNode);
 //fixArrayListString(allArrayListString,elementString,type); 
 //cloneAllNode(srcNodeOrID)
 //ltrim(s)
 //rtrim(s)
 //trim(s)

/** 
 * 弹出指定动作页面
 * 与popupone不同的是popupone调用固定的动作，嵌入指定标签
 * 该方法调用指定动作
 * thisTagOrId 当前标签或标签主键
 * url 指定动作路径
 * title 弹出窗口名
 * width 弹出窗口宽
 * height 弹出窗口高
 * formNodeOrId 提交数据段名或对象
 * showBar 是否显示按钮
 * fullScreen 是否全屏显示
 */
//					  		1	  2	   3	  4		 5			6			7		8
function popupaction(thisTagOrId,url,title, width, height, formNodeOrId, showBar,fullScreen){

	if (url==null){
		return;
	}
	if (showBar==null){
		showBar = "yes";
	}
	var features = ""; //样式
	features += "toolbar="+showBar+",location="+showBar+",status="+showBar+",menubar="+showBar+",scrollbars=yes,resizable=yes,channelmode="+showBar; //规格
	if (fullScreen){
		features += "',width="+screen.width+",height="+screen.height; //大小
		features += ",top=0,left=0";
	}else{
		features += "',width="+width+",height="+height; //大小
		features += ",top="+Math.round(screen.height/2-height/2)+",left="+Math.round(screen.width/2-width/2);
	}
	
	if (url.indexOf("?")>-1){
		if (url.indexOf(ACTION_EXT_NAME)<0){
			url = url.replace("?",ACTION_EXT_NAME+"?");
		}
	}else{
		url += ACTION_EXT_NAME+"?";
	}
	url += "&";
	url = getFormData(formNodeOrId,url);
	if (url.substring(url.length-1,url.length)=='&'){
		url = url.substring(0,url.length-1);
	}
	//弹出页面
	window.open(url,title,features);
}


/** 
 * 弹出指定HTML页面
 * 与popupone不同的是popupone调用固定的动作，嵌入指定标签
 * 该方法调用指定动作
 * thisTagOrId 当前标签或标签主键
 * url 指定动作路径
 * param 传入对话框的参数
 * width 弹出窗口宽
 * height 弹出窗口高
 * formNodeOrId 提交数据段名或对象
 * showBar 是否显示按钮一等
 * fullScreen 是否全屏显示
 */
//				 			  	  1		  2	  3       4		 5			6
function showModalDialogHTML(thisTagOrId,url,param, width, height, fullScreen){
	if (url==null){
		return;
	}
	//样式
	var features = "status:yes;resizable:yes;directories:yes;help:yes;scroll:yes;";
	if (fullScreen){
		features += "dialogWidth:"+screen.width+"px;dialogHeight:"+screen.height+"px;dialogLeft:0px;dialogTop:0px;";
	}else{
		features += "dialogWidth:"+width+"px;dialogHeight:"+height+"px;dialogLeft:"+Math.round(screen.width/2-width/2)+"px;dialogTop:"+Math.round(screen.height/2-height/2) +"px;";
	}
	if (url.substring(url.length-1,url.length)=='&'){
		url = url.substring(0,url.length-1);
	}
	//弹出页面
	return window.showModalDialog(url,param,features);
}


/** 
 * 弹出指定HTML页面
 * 与popupone不同的是popupone调用固定的动作，嵌入指定标签
 * 该方法调用指定动作
 * thisTagOrId 当前标签或标签主键
 * url 指定动作路径
 * title 弹出窗口名
 * width 弹出窗口宽
 * height 弹出窗口高
 * formNodeOrId 提交数据段名或对象
 * showBar 是否显示按钮一等
 * fullScreen 是否全屏显示
 */
//				 		1		2	 3		4		5		6			7
function popupHTML(thisTagOrId,url,title, width, height, showBar, fullScreen){
	if (url==null){
		return;
	}
	if (showBar==null){
		showBar = "yes";
	}
	var features = ""; //样式
	features += "toolbar="+showBar+",location="+showBar+",status="+showBar+",menubar="+showBar+",scrollbars=yes,resizable=yes,channelmode="+showBar; //规格

	if (fullScreen){
		features += "',width="+screen.width+",height="+screen.height; //大小
		features += ",top=0,left=0";
	}else{
		features += "',width="+width+",height="+height; //大小
		features += ",top="+Math.round(screen.height/2-height/2)+",left="+Math.round(screen.width/2-width/2);
	}
	if (url.substring(url.length-1,url.length)=='&'){
		url = url.substring(0,url.length-1);
	}
	//弹出页面
	window.open(url,title,features);
}




/**
 * 将动作路径中累加form中待提交的数据信息
 * action 动作路径
 * formNodeOrId form对象或主键(可用;分割)
 */
function getFormDataUrl(action,formNodeOrId){
	if (action==null){
		action = "";
	}
	if (formNodeOrId==null){
		return action;
	}
	var sendContent = ""; //提交内容
	//处理form中的值
	if (formNodeOrId!=null){
		if (typeof formNodeOrId == "string"){
			//处理多form主键
			var elems = formNodeOrId.split(";"); //分割出多form主键
			var i = 0;
			while(i<elems.length){
				if (elems[i]!=null){
					try{
						sendContent = getFormData(document.getElementById(elems[i]),sendContent,true);
					}catch(e){
						return;
					}
				}
				i++;
			}
		}else{
			try{
				//处理form对象
				sendContent = getFormData(formNodeOrId,sendContent,true);
			}catch(e){
				return;
			}
		}
	}
	if (sendContent!=nlll && sendContent!=""){
		var point = action.indexOf("?"); //获取参数分隔符
		if (point>-1){
			action = action+"&"+sendContent;
		}else{
			action = action+"?"+sendContent;
		}
	}
	return action;
}


/**
 * 向服务器发送数据并且获取服务器返回内容
 * @param thisTagOrId 当前标签或主键
 * @param url 调用服务器链接
 * @param innerTagNodeOrId 将返回值放入指定的标签对象或主键
 * @param doMethod 加载后调用的方法 该方法的第一个参数永远是methodPara 第二个参数是页面返回内容
 * @param methodPara 调用方法参数
 * @param debugTag 该变量有值时为调试状态
 * @param setValueMode 获取结果后设置标签样式  innerhtml innertext value 默认innerhtml 其他关键字都作为属性名属性名
 * @param isSync 是否让此方法同步执行
 * @param noReturnValue 是否不需要设置返回值
 * @param urlToForm 是否将URL中的参数放入Form中提交
 * @param sendData 将要发送的数据
 * @param noError 不报错
 */
//							  1		  2		  	3				 4		 5		 	 6		   7			8			   9		10		  11		12			13		  14

function sendReturnText(thisTagOrId, url, innerTagNodeOrId, doMethod, methodPara, debugTag, setValueMode, noReturnValue, isSync, urlToForm, sendData, noError) {
	return sendDataReturnText(thisTagOrId,url,null,innerTagNodeOrId, doMethod, methodPara, debugTag, setValueMode, noReturnValue, isSync, urlToForm, sendData, noError);
}

/**
 * 向服务器发送数据并且获取服务器返回内容
 * @param thisTagOrId 当前标签或主键
 * @param url 调用服务器链接
 * @param formNodeOrId 准备提交的form对象或主键
 * @param innerTagNodeOrId 将返回值放入指定的标签对象或主键
 * @param doMethod 加载后调用的方法 该方法的第一个参数永远是methodPara 第二个参数是页面返回内容
 * @param methodPara 调用方法参数
 * @param debugTag 该变量有值时为调试状态
 * @param setValueMode 获取结果后设置标签样式  innerhtml innertext value 默认innerhtml 其他关键字都作为属性名属性名
 * @param isSync 是否让此方法同步执行
 * @param noReturnValue 是否不需要设置返回值
 * @param urlToForm 是否将URL中的参数放入Form中提交
 * @param sendData 将要发送的数据
 * @param noError 不报错
 */
//							  1		 	  2		  3				 4				5		 	 6		   7			8			9			10		  11		12			13		  14
function sendDataReturnText(thisTagOrId, url, formNodeOrId, innerTagNodeOrId, doMethod, methodPara, debugTag, setValueMode, noReturnValue, isSync, urlToForm, sendData, noError) {
	if (thisTagOrId!=null 
			&& typeof(thisTagOrId)=="object" 
			&& thisTagOrId.length>0 && url==null){

		//传入参数采用数组形式
		
		if (thisTagOrId.length>12){
			noError = thisTagOrId[12];
		}
		
		if (thisTagOrId.length>11){
			sendData = thisTagOrId[11];
		}
		
		if (thisTagOrId.length>10){
			urlToForm = thisTagOrId[10];
		}
		
		if (thisTagOrId.length>9){
			isSync = thisTagOrId[9];
		}
		if (thisTagOrId.length>8){
			noReturnValue = thisTagOrId[8];
		}
		if (thisTagOrId.length>7){
			setValueMode = thisTagOrId[7];
		}
		if (thisTagOrId.length>6){
			debugTag = thisTagOrId[6];
		}
		if (thisTagOrId.length>5){
			methodPara = thisTagOrId[5];
		}
		if (thisTagOrId.length>4){
			doMethod = thisTagOrId[4];
		}
		if (thisTagOrId.length>3){
			innerTagNodeOrId = thisTagOrId[3];
		}
		if (thisTagOrId.length>2){
			formNodeOrId = thisTagOrId[2];
		}
		if (thisTagOrId.length>1){
			url = thisTagOrId[1];
		}
		if (thisTagOrId.length>0){
			thisTagOrId = thisTagOrId[0];
		}
	}
	
	if (url==null){
		return;
	}

	var qPoint = url.indexOf("?");
	var tPoint = url.indexOf(".");
	if (qPoint>-1){
		if (tPoint<0 || qPoint<tPoint){
			//如果问号前没有. 说明没有扩展名
			url = url.replace("?",ACTION_EXT_NAME+"?");
		}
	}else if (tPoint<0){
		url += ACTION_EXT_NAME;
	}

	//构造将返回值需要放入的标签
	var innerTag;
	//区域标签主键
	var innerTagID;
	//将返回值设置到标签方式
	var setValueModeOld;
 	innerTag = getNodeByObject(innerTagNodeOrId);
	if (innerTag!=null){
		innerTagID = getNodeIdByObject(innerTag);
	}
	if (!noReturnValue){

		if (innerTag==null){
			return;
		}
		if (setValueMode==null){
			setValueMode = "innerhtml";
			setValueModeOld = setValueMode;
		}else{
			setValueModeOld = setValueMode;
			setValueMode = setValueMode.toLowerCase();
		}
	}
	var req = getXMLHttp(); //返回信息对象
	req.onreadystatechange = function() {
		
		this.returnInnerTag = innerTag; //返回值标签
		this.returnInnerTagId = getNodeIdByObject(innerTag); //返回值标签主键
		this.afterSendDoMethod = doMethod; //发送完要调用的方法
		this.afterSendDoMethodPara = methodPara; //调用方法传入的参数
		this.debugTag = debugTag; //调试模式
		this.setValueMode = setValueMode; //返回值插入模式
		this.noReturnValue = noReturnValue; //是否不需要返回值
		
		if(req.readyState == 4){
			if (req.status < 400) {
				
				var resValue = req.responseText; //返回值
				
				var scriptNodes = null; //脚本标签段
				if(noReturnValue){
					//建立存放脚本标签
					var vNode = document.createElement("DIV");
					vNode.innerHTML = resValue; //设置标签内容
					//获取加载页面脚本段 判断是否有脚本方法，如果有，执行之
					scriptNodes = getElementsInNodeByAttribute(vNode,"name",SCRIPT_INNER_TAG);
				}else{
				
					if (debugTag=="debug"){
						//加载测试内容
						resValue = 
							getPageTest(resValue,url, formNodeOrId, innerTagNodeOrId, doMethod, methodPara, debugTag, setValueMode);
						if (setValueMode=="innerhtml"){
							innerTag.innerHTML = resValue;
						}else if (setValueMode=="innertext"){
							innerTag.innerText = resValue;
						}else if (setValueMode=="value"){
							try{
								innerTag.value = resValue;
							}catch(e){}
						}else{
							try{
								innerTag.setAttribute(setValueModeOld,resValue);
							}catch(e){}
						}
					}else{
						if (setValueMode=="innerhtml"){
							innerTag.innerHTML = resValue;
						}else if (setValueMode=="innertext"){
							innerTag.innerText = resValue;
						}else if (setValueMode=="value"){
							try{
								innerTag.value = resValue;
							}catch(e){}
						}else{
							try{
								innerTag.setAttribute(setValueModeOld,resValue);
							}catch(e){}
						}
					}
					//获取加载页面脚本段 判断是否有脚本方法，如果有，执行之
					scriptNodes = getElementsInNodeByAttribute(innerTag,"name",SCRIPT_INNER_TAG);
				}

				if (scriptNodes!=null){
					var i=0;
					while(i<scriptNodes.length){
						if (scriptNodes[i]!=null){
							eval(scriptNodes[i].value); //执行脚本中的方法
						}
						i++;
					}
				}
	
				if (doMethod!=null){
					try{
						doMethod(methodPara,resValue)//调用方法
					}catch(e){}
				}
			}else{
				if (!noError){
					if (noReturnValue){
						alert("服务器繁忙请稍后再试!");
					}else{
						resText = getPageError(null,url, formNodeOrId, innerTagNodeOrId, doMethod, methodPara, debugTag, setValueMode); //加载系统超时提示页面
						
						if (setValueMode=="innerhtml"){
							innerTag.innerHTML = resText;
						}else if (setValueMode=="innertext"){
							innerTag.innerText = resText;
						}else {
							try{
								innerTag.value = resText;
							}catch(e){}
						}
					}
				}
			}
		}
	}
	var sendContent = "";
	//处理form中的值
	if (formNodeOrId!=null){
		if (typeof formNodeOrId == "string"){
			//处理多form主键
			var elems = formNodeOrId.split(";"); //分割出多form主键
			var i = 0;
			while(i<elems.length){
				if (elems[i]!=null){
					try{
						sendContent = getFormData(document.getElementById(elems[i]),sendContent,true);
					}catch(e){
						return;
					}
				}
				i++;
			}
		}else{
			try{
				//处理form对象
				sendContent = getFormData(formNodeOrId,sendContent,true);
			}catch(e){
				return;
			}
		}
	}
	var thisAction;
	//将URL中的参数转移到发送数据中
	if (url.indexOf("?")>-1){
		if (urlToForm){
			sendContent += "&"+url.substring(url.indexOf("?")+1,url.length)+"&";
			url = url.substring(0,url.indexOf("?"));
			thisAction = url;
		}else{
			thisAction = url.substring(0,url.indexOf("?"));
		}
		//url += "&___randid="+Math.random(); //如果加上这句话,缓存就失效了
	}else{
		thisAction = url;
		//url += "?___randid="+Math.random(); //如果加上这句话,缓存就失效了
	}
	try{
		if (!isSync && !noReturnValue && setValueMode=="innerhtml"){
			//加载稍候界面
			innerTag.innerHTML = getPagePleaseWait();
		}
	}catch(e){}
	//累加要发送的数据
	if (sendData!=null && sendData!=""){
		if (sendContent==null || sendContent==""){
			sendContent = sendData;
		}else{
			sendContent += "&"+sendData;
		}
	}
	if (url.substring(url.length-1,url.length)=='&'){
		url = url.substring(0,url.length-1);
	}
	//alert(url); //测试链接值
	//打开连接
	if (isSync){
		req.open("POST",url, false);
	}else{
		req.open("POST",url, true);
	}
	req.setRequestHeader("CONTENT-TYPE","application/x-www-form-urlencoded");
	
	try{
		//alert(sendContent);
		req.send(sendContent);
	}catch(e){}
	
	return req;
}


/**
 * 获取新的节点，并且将html内容放入节点
 * htmlText html内容
 * nodeName 节点名 默认div
 */
function getNewElement(htmlText,nodeName){

	if (nodeName==null || nodeName==""){
		nodeName = "div";
	}
	//构造新节点
	var newNode = document.createElement(nodeName);
	
	//设置节点内容
	newNode.innerHTML = htmlText;
	
	return newNode;
}




/**
 * 获取指定标签最近的一个符合属性名和属性值的标签
 * tagOrId 指定标签或标签主键
 * attributeName 属性名
 * attributeValue 属性值
 */
function getNodeByNeighborhood(tagOrId,attributeName,attributeValue){

	//获取当前标签
	var node = getNodeByObject(tagOrId);
	if (node==null){
		return null;
	}
	//获取当前节点范围内，符合指定属性名和值的节点
	var reNode = 
		getElementInNodeByAttribute(node,attributeName,attributeValue);
	if (reNode!=null){
		return reNode;
	}
	//获取节点名
	var nodeName;
	try{
		nodeName = node.nodeName;
	}catch(e){}
	if (nodeName=="#document"){
		//已经到了顶层
		return null;
	}
	var parentNode = null;
	try{
		parentNode = node.parentNode;
	}catch(e){}
	if (parentNode!=null){
		return getNodeByNeighborhood(parentNode,attributeName,attributeValue);
	}
}


/**
 * 检测标签中的html中是否包含脚本方法，如果包含，执行之
 * innerTagOrId html标签
 */
function checkScriptFromInnerTag(innerTagOrId){

	this.returnInnerTag = getNodeByObject(innerTagOrId); //返回值标签
	this.returnInnerTagId = getNodeIdByObject(innerTagOrId); //返回值标签主键

	var executed = false; //是否执行了脚本
	var innerTag = getNodeByObject(innerTagOrId);
	if (innerTag==null){
		return executed;
	}
	
	//获取加载页面脚本段
	var scriptNodes = getElementsInNodeByAttribute(innerTag,"name",SCRIPT_INNER_TAG);
	if (scriptNodes!=null){
		var i=0;
		while(i<scriptNodes.length){
			if (scriptNodes[i]!=null){
				eval(scriptNodes[i].value); //执行脚本中的方法
				executed = true;
			}
			i++;
		}
	}
	return executed;
}


/**
 * 检查html内容中是否包含脚本文本
 * html html内容文本
 */
function checkScriptFromHTML(html){
	try{
		return checkScriptFromInnerTag(getNewElement(html));
	}catch(e){}
	return false;
}



/**
 * 获取指定板块中符合标签名的标签
 * nodeOrId 板块对象或板块主键
 * nodeName 标签名
 */
function getNodeElementsByNodeName(nodeOrId,nodeName){

		var reArrl = []; //构建返回值
		var node = getNodeByObject(nodeOrId);
		if (node==null || nodeName==null || nodeName==""){
			return reArrl;
		}
		nodeName = nodeName.toUpperCase(); //转换为大写
		var nodeValue = "";
		try{
			nodeValue = node.nodeName;
		}catch(e){}
		//alert(node.canHaveChildren);
		if (nodeName==nodeValue){
			reArrl[reArrl.length] = node;
		}
		if (!node.canHaveChildren){
			return reArrl;
		}
		//获取当前节点中所有的可操作子节点
		var elements = node.children;	
		//获取子节点数量
		var elementCount = 0;
		try{
			elementCount = elements.length;
		}catch(e){}
		if (elementCount==0){
			return reArrl;
		}
		var elementNo = 0;
		while(elementNo<elementCount){
			if (elements[elementNo]==null){
				continue;
			}
			var chNodeArrl = getNodeElementsByNodeName(elements[elementNo],nodeName);
			if (chNodeArrl!=null){
				var i=0;
				while(i<chNodeArrl.length){
					reArrl[reArrl.length] = chNodeArrl[i];
					i++;
				}
			}
			elementNo++;
		}
		return reArrl;
	}


/**
 * 根据主键获取节点（不会抛异常)
 * @param id 主键
 * @return element 元素
 * 2007-02-12
 */
function getNodeById(id){
	try{
		return document.getElementById(id);
	}catch(e){}
	return null;
}

/**
 * 根据节点的属性名获取属性值 不会抛异常
 * @param node 指定节点
 * @param attribName 节点属性名
 * @return 返回节点属性值
 */
function getNodeAttribute(node,attribName){
	var res; //构造返回值
	try{
		//获取节点指定属性
		res = node.getAttribute(attribName);
	}catch(e){}
	if (res==null){
		res = "";
	}
	return res;
}

/**
 * 获取节点名称
 * @param node 指定节点
 * @return 返回节点名称
 */
 function getNodeName(node){
 	 var res; //构造返回值
 	 try{
 	 	 res = node.nodeName;
 	 }catch(e){}
 	 if (res==null){
 	 	 res = "";
 	 }
 	 return res;
 }
 
 
 /**
  * 将form中的值转换成xml对象提交的字符串
  * 目前支持的提交对象 input select textarea
  * @param submitForm 将要提交的form
  * @param res 返回值，该方法是递归方法，需要将上级返回值设置到下级方法中。在其它方法调用此方法时，res设置为空字符串
  * @param needCheck 是否需要校验
  * @return varName1=varValue1&varName2=varValue2字符串
  */
function getFormData(submitForm,res,needCheck){
	//获取对象
	submitForm = getNodeByObject(submitForm);
	if (submitForm==null){
		return res;
	}
	//获取当前节点中所有的可操作子节点
	var elements = submitForm.children;	
	//获取子节点数量
	var elementCount = 0;
	try{
		elementCount = elements.length;
	}catch(e){}
	if (elementCount==0){
		res += getElementSubmitPara(submitForm,needCheck);
		return res;
	}
	var elementNo = 0;
	
	while(elementNo<elementCount){
		if (elements[elementNo]==null){
			continue;
		}
		//TEXTAREA 的子节点中都是文本
		if (elements[elementNo].canHaveChildren 
				&& getNodeName(elements[elementNo])!="TEXTAREA"
				&& getNodeName(elements[elementNo])!="SELECT"){
					
			res = getFormData(elements[elementNo],res,needCheck);
		}else{
			res += getElementSubmitPara(elements[elementNo],needCheck);
		}
		elementNo++;
	}
	return res;//URLEncode(res);
}

/**
 * 根据参数获取指定的节点
 * nodeOrId 节点对象或节点主键值
 */
function getNodeByObject(nodeOrId){
	if (nodeOrId==null){
		return null;
	}
	var node = null;
	try{
		if (typeof nodeOrId == "string"){
			node = document.getElementById(nodeOrId);
		}else{
			node = nodeOrId;
		}
	}catch(e){}
	if (typeof node == "undefined"){
		return null;
	}
	return node;
}

/**
 * 根据参数获取节点主键值
 * nodeOrId 节点对象或节点主键值
 */
function getNodeIdByObject(nodeOrId){
	if (nodeOrId==null){
		return null;
	}
	try{
		if (typeof nodeOrId == "string"){
			return nodeOrId;
		}else{
			return nodeOrId.id;
		}
	}catch(e){
		return null;
	}
}


/**
 * 在指定标签范围内获取指定主键值的节点
 * nodeOrId 节点对象或者是节点id属性值
 * idValue 节点主键值
 */
function getNodeElementById(nodeOrId,idValue){
	
	if (idValue==null){
		return null;
	}
	var node = getNodeByObject(nodeOrId);
	if (node==null){
		return null;
	}
	if (node.id==idValue){
		return node;
	}
	if (node.nodeName=="#document"){
		node = node.body;
	}
	if (!node.canHaveChildren){
		return null;
	}
	//获取当前节点中所有的可操作子节点
	var elements = node.children;	
	//获取子节点数量
	var elementCount = 0;
	try{
		elementCount = elements.length;
	}catch(e){}
	if (elementCount==0){
		return null;
	}
	var elementNo = 0;
	while(elementNo<elementCount){
		if (elements[elementNo]==null){
			continue;
		}
		var reNode = getNodeElementById(elements[elementNo],idValue);
		if (reNode!=null){
			return reNode;
		}
		elementNo++;
	}
	return null;
}


/**
 * 从整个页面中获取指定属性值的标签
 * attributeName 属性名
 * attributeValue 属性值
 */
function getElementsInDocumentByAttribute(attributeName,attributeValue){

	var nodes = document.childNodes;
	var reNodeArr = [];
	var i=0;
	while(i<nodes.length){
		var elementNodesArr = 
			getElementsInNodeByAttribute(nodes[i],attributeName,attributeValue);
		if (elementNodesArr!=null){
			var j=0;
			while(j<elementNodesArr.length){
				reNodeArr[reNodeArr.length] = elementNodesArr[j];
				j++;
			}
		}
		i++;
	}
	return reNodeArr;
}

/**
 * 获取节点中 attributeName值相符的节点数组
 * nodeOrId 节点对象或者是节点id属性值
 * attributeName 属性名
 * attributeValue 属性值
 */
function getElementsInNodeByAttribute(nodeOrId,attributeName,attributeValue){

	var reArrl = []; //构建返回值
	var node = getNodeByObject(nodeOrId);
	if (node==null){
		return reArrl;
	}
	var idValue = getNodeAttribute(node,attributeName);
	if (idValue!=null && idValue==attributeValue){
		reArrl[reArrl.length] = node;
	}
	if (node.nodeName=="#document"){
		node = node.body;
	}
	try{
		if (!node.canHaveChildren){
			return reArrl;
		}
	}catch(e){
		return reArrl;
	}
	//获取当前节点中所有的可操作子节点
	var elements = null;
	try{
		elements = node.children;
	}catch(e){
		return reArrl;
	}
	
	//获取子节点数量
	var elementCount = 0;
	try{
		elementCount = elements.length;
	}catch(e){}
	if (elementCount==0){
		return reArrl;
	}
	var elementNo = 0;
	while(elementNo<elementCount){
		if (elements[elementNo]==null){
			continue;
		}
		var chNodeArrl = getElementsInNodeByAttribute(elements[elementNo],attributeName,attributeValue);
		if (chNodeArrl!=null){
			var i=0;
			while(i<chNodeArrl.length){
				reArrl[reArrl.length] = chNodeArrl[i];
				i++;
			}
		}
		elementNo++;
	}
	return reArrl;
}

/**
 * 获取节点中 attributeName值相符的节点
 * nodeOrId 节点对象或者是节点id属性值
 * attributeName 属性名
 * attributeValue 属性值
 */
function getElementInNodeByAttribute(nodeOrId,attributeName,attributeValue){

	var node = getNodeByObject(nodeOrId);
	if (node==null){
		return null;
	}
	var idValue = getNodeAttribute(node,attributeName);
	if (idValue!=null && idValue==attributeValue){
		return node;
	}
	if (node.nodeName=="#document"){
		node = node.body;
	}
	if (!node.canHaveChildren){
		return null;
	}
	//获取当前节点中所有的可操作子节点
	var elements = node.children;	
	//获取子节点数量
	var elementCount = 0;
	try{
		elementCount = elements.length;
	}catch(e){}
	if (elementCount==0){
		return null;
	}
	var elementNo = 0;
	while(elementNo<elementCount){
		if (elements[elementNo]==null){
			continue;
		}
		var reNode = getElementInNodeByAttribute(elements[elementNo],attributeName,attributeValue);
		if (reNode!=null){
			return reNode;
		}
		elementNo++;
	}
	return null;
}


/**
 * 将元素中提取出要提交的参数值拼装成提交字符串片断
 * @param elem 将要提取的节点元素
 * @param needCheck 是否需要校验
 */
function getElementSubmitPara(elem,needCheck){
	var nodeName; //节点名
	var attribType; //提交对象类型
	var attribName; //提交参数名
	var attribValue; //提交参数值

	//获取节点名
	nodeName = getNodeName(elem);
	if (nodeName==null || nodeName=="" || nodeName.indexOf("/")==0){
		return "";
	}
	//获取提交参数名
	attribName = getNodeAttribute(elem,"name");
	
	if (attribName==""){
		return "";
	}
	if (nodeName=="INPUT"){ //INPUT
		//获取提交参数值
		attribValue = getNodeAttribute(elem,"value");
		//获取input的类型
		attribType = getNodeAttribute(elem,"type");
		if (attribType=="" 
				|| attribType=="image" 
				|| attribType=="reset"){
			return "";
		}else{
			if (attribType=="radio" || attribType=="checkbox"){
				try{
					//只提交选择了的参数
					if (!elem.checked){
						return "";
					}
				}catch(e){}
			}
		}
	}else if (nodeName=="SELECT"){ //SELECT
		//获取提交参数值
		attribValue = getNodeAttribute(elem,"value");
	}else if (nodeName=="TEXTAREA"){ //TEXTAREA
		attribValue = elem.innerText;
		if (attribValue==null){
			attribValue = "";
		}
	}
	if (attribName==null || attribName==""){
		return "";
	}
	if (attribValue==null){
		attribValue = "";
	}
	if (needCheck){
		//获取校验类型
		var checktype = getNodeAttribute(elem,ATTRIBUTE_CHECK_TYPE);
		if (checktype!=null && checktype!=""){
			//校验标签值
			checkTagValue(elem,attribValue,checktype);
		}
	}
	return attribName+"="+URLEncodePro(attribValue)+"&";
}



/**
 * 检测指定标签是否合法 不合法则抛异常
 * tagOrId 指定标签主键或标签对象
 * checkValue 检测值
 * checkType 检测类型字符串 多类型用，分割
 * digit[全数字],
 */
function checkTagValue(tagOrId,checkValue,checkType){

	if (checkType==null || checkType==""){
		return;
	}
	//获取检测类型数组
	var checkTypes = checkType.split(",");
	var i=0; //循环变量
	var errorMsg; //错误信息
	var isError = false; //是否发生了异常
	while(i<checkTypes.length){
	
		if(checkTypes[i]==null){
			i++;
			continue;
		}
	
		if (checkValue==null || checkValue==""){
			if (checkTypes[i]=="nonull"){
				errorMsg = "请输入值";
				isError = true;
			}
		}else{
			if (checkTypes[i].indexOf("maxnum:")>-1){
				//长度
				var size = new Number(checkTypes[i].substring("maxnum:".length,checkTypes[i].length));
				if (checkValue!=null && checkValue.length>size){
					errorMsg = "输入的值的长度大于:"+size;
					isError = true;
				}
			}else if (checkTypes[i].indexOf("minnum:")>-1){
				//长度
				var size = new Number(checkTypes[i].substring("minnum:".length,checkTypes[i].length));
				if (checkValue!=null && checkValue.length<size){
					errorMsg = "输入的值的长度小于:"+size;
					isError = true;
				}
			}else if (checkTypes[i].indexOf("same:")>-1){
				var anOtherNode;
				try{
					anOtherNode = document.getElementById(checkTypes[i].substring("same:".length,checkTypes[i].length))
				}catch(e){}
				if (anOtherNode==null){
					errorMsg = "程序错误：没有找到校验信息输入框";
					isError = true;
				}else if (anOtherNode.value!=checkValue){
					errorMsg = "输入值与重复输入值不同，请重新输入";
					isError = true;
				}
			}else if (checkTypes[i]=="digit" && isDigitError(checkValue)){
				errorMsg = "输入的值不是数字";
				isError = true;
			}else if (checkTypes[i]=="stringa" && checkStringErrorA(checkValue)){
				errorMsg = "输入的值不合法：只能输入5-20个以字母开头、可带数字、\"_\"、\".\"的字串";
				isError = true;
			}else if (checkTypes[i]=="stringb" && checkStringErrorB(checkValue)){
				errorMsg = "输入的值不合法：只能输入1-30个以字母开头的字串";
				isError = true;
			}else if (checkTypes[i]=="stringc" && checkStringErrorC(checkValue)){
				errorMsg = "输入的值不合法：只能输入6-20个字母、数字、下划线";
				isError = true;
			}else if (checkTypes[i]=="tel" && isTelError(checkValue)){
				errorMsg = "输入的号码格式错误：可以\"+\"开头，除数字外，可含有\"-\"";
				isError = true;
			}else if (checkTypes[i]=="mobil" && isMobilError(checkValue)){
				errorMsg = "输入的手机号格式错误：必须以数字开头，除数字外，可含有\"-\"";
				isError = true;
			}else if (checkTypes[i]=="postal" && isPostalCode(checkValue)){
				errorMsg = "输入的邮政编码错误";
				isError = true;
			}else if (checkTypes[i]=="email" && isEmailError(checkValue)){
				errorMsg = "输入的邮件地址错误";
				isError = true;
			}else if (checkTypes[i]=="dateymd" && isDateYMDError(checkValue)){
				errorMsg = "输入的日期错误: 应为 年年年年-月月-日日";
				isError = true;
			}else if (checkTypes[i]=="dateymdh" && isDateYMDHError(checkValue)){
				errorMsg = "输入的时间错误: 应为 年年年年-月月-日日 时时";
				isError = true;
			}else if (checkTypes[i]=="dateymdhm" && isDateYMDHMError(checkValue)){
				errorMsg = "输入的时间错误: 应为 年年年年-月月-日日 时时:分分";
				isError = true;
			}else if (checkTypes[i]=="dateymdhms" && isDateYMDHMSError(checkValue)){
				errorMsg = "输入的时间错误: 应为 年年年年-月月-日日 时时:分分:秒秒";
				isError = true;
			}else if (checkTypes[i]=="dateymdhmspro" && isDateYMDHMSProError(checkValue)){
				errorMsg = "输入的时间错误: 应为 年年年年-月月-日日 时时:分分";
				isError = true;
			}else if (checkTypes[i]=="float" && checkFloatError(checkValue)){
				errorMsg = "输入的数字错误: 内容中只能包含数字，小数点和负号";
				isError = true;
			}else if (checkTypes[i]=="blank" && checkBlankError(checkValue)){
				errorMsg = "不能包含空格";
				isError = true;
			}else if (checkTypes[i]=="corpschar" && checkCorpsCharError(checkValue)){
				errorMsg = "不能包含特殊字符";
				isError = true;
			}
		}

		
		if (isError){
			var tagNode = getNodeByObject(tagOrId);
			if (tagNode!=null){
				try{
					tagNode.focus();
				}catch(e){}
			}
			alert(errorMsg);
			throw errorMsg;
		}
		
		i++;
	}
}

/**
 * 校验字符串中不能有空格
 * s 校验对象
 * true 错误
 */
function checkBlankError(s){
	var len1 = s.length;
	var s = s.replace(/[\s+　]/g,"");
	var len2 = s.length;
	if(len1>len2) {
		return true;
	}
	return false;
}

/**
 * 校验字符串中不能有特殊字符
 * s 校验对象
 * true 错误
 */
function checkCorpsCharError(s){
     var len;
     var regArray = new Array('','@','!','#','$','%','^','&','*','(',')','~','%','!','<','>','‰','//','\\','`','[',']','{','}','?'); 
     len = regArray.length;
     var i = 0;
     while(i<=len){
        if (s.indexOf(regArray[i])!=-1){
               return true;
        }
     	i++;
     }
 	 return false;    
}

/**
 * 校验邮件地址
 * s 校验对象
 * true 错误
 */
function isEmailError(s) {
	var patrn=/^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}

/**
 * 校验年月日小时分钟秒
 * s 校验对象
 * true 错误
 */
function isDateYMDHMSError(s) {
	var patrn=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}

/**
 * 校验年月日小时分钟秒
 * s 校验对象
 * true 错误
 */
function isDateYMDHMSProError(s) {
	var patrn=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/;
	var patrnsec = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2})$/;
	var patrnthr = /^(\d{4})-(\d{2})-(\d{2})         $/;
	var patrnfor = /^(\d{4})-(\d{2})-(\d{2})$/;
	if (patrn.exec(s) || patrnsec.exec(s) || patrnthr.exec(s) || patrnfor.exec(s)){
		return false;
	}
	return true;
}

/**
 * 校验年月日小时分钟
 * s 校验对象
 * true 错误
 */
function isDateYMDHMError(s) {
	var patrn=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2})$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}



/**
 * 校验年月日小时
 * s 校验对象
 * true 错误
 */
function isDateYMDHError(s) {
	var patrn=/^(\d{4})-(\d{2})-(\d{2}) (\d{2})$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}

/**
 * 校验年月日
 * s 校验对象
 * true 错误
 */
function isDateYMDError(s) {
	var patrn=/^(\d{4})-(\d{2})-(\d{2})$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}

/**
 * 校验邮政编码
 * s 校验对象
 * true 错误
 */
function isPostalCode(s) {
	var patrn=/^[0-9](\d){5}(?!d)/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}


/**
 * 校验手机号码：必须以数字开头，除数字外，可含有\"-\"
 * s 校验对象
 * true 错误
 */
function isMobilError(s) {
	var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}



/**
 * 校验电话号:普通电话、传真号码：可以“+”开头，除数字外，可含有“-” 
 * s 校验对象
 * true 错误
 */
function isTelError(s) {
	var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?(\d){1,12})+$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}




/**
 * 校验字符串：只能输入6-20个字母、数字、下划线
 * s 校验对象
 * true 错误
 */
function checkStringErrorC(s) {
	var patrn=/^(\w){6,20}$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}


/**
 * 校验字符串：只能输入1-30个以字母开头的字串
 * s 校验对象
 * true 错误
 */
function checkStringErrorB(s) {
	var patrn=/^[a-zA-Z]{1,30}$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}


/**
 * 校验字符串 只能输入5-20个以字母开头、可带数字、“_”、“.”的字串
 * s 校验对象
 * 错误
 */
function checkStringErrorA(s) {
	var patrn=/^[a-zA-Z]{1}([a-zA-Z0-9]|[._]){4,19}$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}


/**
 * 校验字符串是否为浮点数字 带数字，小数点，负号
 * s 校验对象
 * 错误
 */
function checkFloatError(s) {
	var patrn=/^[0-9]|[.-]$/;
	if (patrn.exec(s)){
		return false;
	}
	return true;
}


/**
 * 校验是否为全数字
 * s 校验对象
 * true 不是全数字
 */
function isDigitError(s) {
	var patrn=/^[0-9]{1,20}$/; //构造校验字符串
	if (patrn.exec(s)){
		 return false;
	}
	return true;
}




/**
 * 过滤特殊字符
 * @param plaintext 过滤前字符
 * @return 过滤后字符
 */
function URLEncodePro(plaintext){

	if (plaintext==null){
		return "";
	}
	if (plaintext==""){
		return plaintext;
	}
	return plaintext
			.replace(/%/g,"%25")
			.replace(/=/g,"%3D")
			.replace(/\+/g,"%2B")
			.replace(/ /g,"+")
			.replace(/\n/g,"%0D")
			.replace(/#/g,"%23")
			.replace(/\'/g,"%27")
			.replace(/\,/g,"%2C")
			.replace(/\"/g,"%22")
			.replace(/\;/g,"%3B")
			.replace(/\./g,"%2E")
			.replace(/\-/g,"%2D")
			.replace(/:/g,"%3A")
			.replace(/\//g,"%2F")
			.replace(/\r/g,"")
			.replace(/\t/g,"%09")
			.replace(/&/g,"%26")
			.replace(/\?/g,"%3F")
			.replace(/!/g,"%21")
			.replace(/</g,"%3C")
			.replace(/>/g,"%3E")
			.replace(/\\/g,"%5C");
}

/**
 * 将内容进行URL编码
 * @param plaintext 源字符串
 * @return 编码后的字符串
 */
function URLEncode(plaintext) {

	var SAFECHARS = "0123456789" +					// Numeric
					"ABCDEFGHIJKLMNOPQRSTUVWXYZ" +	// Alphabetic
					"abcdefghijklmnopqrstuvwxyz";// +
					//"&="; //提交参数用
					//"-_.!~*'()";					// RFC2396 Mark characters 
	var HEX = "0123456789ABCDEF";

	var encoded = ""; //构建返回值
	//循环处理字节
	for (var i = 0; i < plaintext.length; i++ ) {
		var ch = plaintext.charAt(i);
	    if (ch == " ") {
		    encoded += "+";				// x-www-urlencoded, rather than %20
		} else if (SAFECHARS.indexOf(ch) != -1) {
		    encoded += ch;
		} else {
		    var charCode = ch.charCodeAt(0);
			if (charCode > 255) {
				encoded += ch;
			} else {
				encoded += "%";
				encoded += HEX.charAt((charCode >> 4) & 0xF);
				encoded += HEX.charAt(charCode & 0xF);
			}
		}
	}
	return encoded;
}


/**
 * 获取包含双字节字符串的实际长度(一个双字节字符算2个字节)
 * 源字符串
 */
function doubleCharLength(str){

	var iLen =0; //构建返回值
	var iSize = str.length; //获取字符串总长度 汉字等算1个字
	var i=0;	//循环变量
	var iCode; //临时变量
	while(i<iSize){
		//获取一个字节
		iCode = str.charCodeAt(i);
		if(iCode>=0 && iCode<=128) {
			iLen ++;
		}else {
			iLen +=2;
		}
		i++;
	}
	return iLen;
}


/**
 * 将编码后的字符串解编码
 * 还在开发中，目前不支持中文
 * @param encoded 编码后的字符串
 * @return 解编码后的字符串
 */
function URLDecode(encoded) {
	
   var HEXCHARS = "0123456789ABCDEFabcdef"; 
   
   //构建返回值
   var plaintext = "";
   //构建循环指针
   var i = 0;
   while (i < encoded.length) {
       var ch = encoded.charAt(i);
	   if (ch == "+") {
	       plaintext += " ";
		   i++;
	   } else if (ch == "%") {
			if (i < (encoded.length-2) 
					&& HEXCHARS.indexOf(encoded.charAt(i+1)) != -1 
					&& HEXCHARS.indexOf(encoded.charAt(i+2)) != -1 ) {
				plaintext += unescape( encoded.substr(i,3) );
				i += 3;
			} else {
				plaintext += "%[ERROR]";
				i++;
			}
		} else {
		   plaintext += ch;
		   i++;
		}
	} 
	return plaintext;
}

/**
 * 加载请稍候界面
 */
function getPagePleaseWait(){
	return "<div id='___pleasewait'><img src='/images/ajax-loader.gif' border='0'/>&nbsp;请稍候...</div>";
	
}

/**
 * 执行超时时加载页面
 */
//						 1	   2		3				4			  5			 6			7			8
function getPageError(content,url, formNodeOrId, innerTagNodeOrId, doMethod, methodPara, debugTag, setValueMode){
	if (content==null){
		content = "系统忙";
	}
	return  "<div class=\"pleaseWait\"><font color=\"red\">"+content+"，请稍候点击刷新按钮</font><input type=\"button\" name=\"btrefresh\" value=\"刷新\" onclick=\"javascript:sendDataReturnText(null,'"+url+"','"+getNodeIdByObject(formNodeOrId)+"','"+getNodeIdByObject(innerTagNodeOrId)+"',"+getMethodName(doMethod)+",'"+methodPara+"','"+debugTag+"','"+setValueMode+"');\" style=\"BORDER: #ffffff 1px solid;PADDING:6px 2px 1px 2px;FONT-SIZE: 12px;FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#d1d1d1);CURSOR: hand;\" /></div>";
}

/**
 * 调用测试页面
 */
//						  1		  2			3				4			 5			6			7			8
function getPageTest(pageContent,url, formNodeOrId, innerTagNodeOrId, doMethod, methodPara, debugTag, setValueMode){
	return pageContent+"<br/><textarea cols=\"50\" rows=\"10\" id=\"debugtestarea097876\">"
		   +pageContent+"</textarea><input type=\"button\" name=\"testbt1\" value=\"刷新\" onclick=\"javascript:sendDataReturnText(null,'"+url+"','"+getNodeIdByObject(formNodeOrId)+"','"+getNodeIdByObject(innerTagNodeOrId)+"',"+getMethodName(doMethod)+",'"+methodPara+"','"+debugTag+"','"+setValueMode+"');\" "
		   +" style=\"BORDER: #ffffff 1px solid;PADDING:6px 2px 1px 2px;FONT-SIZE: 12px;FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#d1d1d1);CURSOR: hand;\" />";
}


/**
 * 获取方法名称
 */
 function getMethodName(doMethod){
	if (doMethod!=null){
		var methodBody = doMethod.toString();
	    return methodBody.substring(methodBody.toLowerCase().indexOf("function")+9,methodBody.indexOf("("));
	}
	return null;
 }
 

/**
 * 克隆指定节点（包含其子中的所有子节点) 递归函数
 * srcNode 原节点 或节点主键
 */
function cloneAllNode(srcNodeOrID){
	
	var srcNode = getNodeByObject(srcNodeOrID);
	if (srcNode==null){
		return null;
	}
	var nodeType = srcNode.nodeType; //节点类型
	if (nodeType==null){
		//非节点对象，比如脚本函数
		return srcNode;
	}
	var reNode = srcNode.cloneNode();
	if (srcNode.hasChildNodes){
		//获取当前节点下的所有子节点
		var childNodes = srcNode.childNodes;
		var nodeCount = childNodes.length;
		var i=0;
		while(i<nodeCount){
			reNode.appendChild(cloneAllNode(childNodes[i]));
			i++;
		}
	}
	return reNode;
}

/**
 * 复制form中的内容到另外一个form中
 */
function copyForm(srcFormOrId,objFormOrId,objDocument){

	//获取对象
	objFormOrId = getNodeByObject(objFormOrId);
	
	var tagList = []; //构建提交标签序列
	
	//获取所有需要提交的标签序列
	getAllSubmitTag(srcFormOrId,tagList);
	
	//获取提交标签数量
	var tagCount = tagList.length;
	
	var i=0; //循环指针
	while(i<tagCount){
		//放入目标标签中
		var nodeName = tagList[i].nodeName;
		var objTag = objDocument.createElement(nodeName);
		objTag.name=tagList[i].name;
		if (nodeName=='INPUT'){
			objTag.setAttribute('type',tagList[i].getAttribute('type'));
			objTag.setAttribute('value',tagList[i].getAttribute('value'));
		}else if (nodeName=='SELECT'){
			objTag = objDocument.createElement("INPUT");
			objTag.name=tagList[i].name;
			objTag.setAttribute('type','hidden');
			if (tagList[i].selectedIndex>-1){
				objTag.setAttribute('value',tagList[i].options[tagList[i].selectedIndex].value.toString());
			}
		}else if (nodeName=='TEXTAREA'){
			objTag.innerHTML = tagList[i].innerHTML;
		}else{
			i++;
			continue;
		}
		objFormOrId.appendChild(objTag);
		i++;
	}
}

/**
 * 将指定标签中所有可以提交的标签放到序列中 (递归函数)
 * formOrId 指定标签
 * 标签序列
 */
function getAllSubmitTag(formOrId,tagList){

	//获取对象
	formOrId = getNodeByObject(formOrId);
	
	//获取当前节点中所有的可操作子节点
	var elements = formOrId.children;

	//获取子节点数量
	var elementCount = 0;
	try{
		elementCount = elements.length;
	}catch(e){}
	
	//获取节点名
	var nodeName = getNodeName(formOrId);
	if (elementCount==0 || nodeName=="SELECT"){

		if (nodeName==null || nodeName=="" || nodeName.indexOf("/")==0){
			return;
		}
		//获取提交参数名
		attribName = getNodeAttribute(formOrId,"name");
		
		if (attribName==""){
			return;
		}
		if (nodeName=="INPUT" 
				|| nodeName=="SELECT"
				|| nodeName=="TEXTAREA"){
			//放入序列中
			tagList[tagList.length] = formOrId;
		}
	}
	var elementNo = 0;
	
	while(elementNo<elementCount){
		if (elements[elementNo]==null){
			continue;
		}
		//递归调用
		getAllSubmitTag(elements[elementNo],tagList);
		elementNo++;
	}
}

/**
 * 获取随机字符串 20位
 */
function getSid(){
	var time = new String((new Date()).getTime());
	var randomStr = new String(Math.random());
	randomStr = randomStr.substring(2,randomStr.length);
	return (time+randomStr).substring(0,20);
}


/**
 * 通过指定属性移除指定节点
 * parentNodeOrId 父节点或节点主键
 * attribName 属性名
 * attribValue 属性值
 */
function removeNodeByAttribute(parentNodeOrId,attribName,attribValue){

	var parentNode = getNodeByObject(parentNodeOrId); //获取父节点
	if (parentNode==null){
		return;
	}
	//获取父节点下的子节点
	var childNodes = null;
	try{
		childNodes = parentNode.childNodes;
	}catch(e){}
	if (childNodes==null){
		return;
	}
	//获取克隆后的子节点
	var fixChildNodes = cloneAllNode(parentNode).childNodes;
	var childNodeCount = fixChildNodes.length; //子节点总数

	parentNode.innerHTML = "";
	
	var ii = 0;
	while(ii<childNodeCount){
		var i = ii;
		ii++;
		if (fixChildNodes[i]==null){
			continue;
		}
		if (getNodeAttribute(fixChildNodes[i],attribName)==attribValue){
			continue;
		}
		parentNode.appendChild(fixChildNodes[i]);
	}
}

/**
 * 移动指定节点
 * thisNodeOrId 指定节点或节点主键
 * type 0移动到父节点开头位置 1父节点末尾位置  2移动到上一个同级节点 3移动到下一个同级节点
 */
function moveNode(thisNodeOrId,type){

	var thisNode = getNodeByObject(thisNodeOrId); //获取节点
	if (thisNode==null){
		return;
	}
	//获取父节点
	var parentNode = null;
	try{
		parentNode = thisNode.parentNode;
	}catch(e){}
	
	//获取父节点下的子节点
	var childNodes = null;
	try{
		childNodes = parentNode.childNodes;
	}catch(e){}
	if (childNodes==null){
		return;
	}
	var thisNodePoint = 0; //指定节点在父节点中的位置
	while(childNodes[thisNodePoint]!=thisNode){
		thisNodePoint++;
	}
	//获取克隆后的子节点
	var fixChildNodes = cloneAllNode(parentNode).childNodes;
	var childNodeCount = fixChildNodes.length; //子节点总数
	
	var moveNode1 = null; //被移动的节点 1
	var moveNode2 = null;
	
	var movePoint1 = thisNodePoint; //移动到的位置1
	var movePoint2 = thisNodePoint; //移动到的位置2
	
	if (type==2){
		//移动到上一个同级节点
		movePoint2--;
		if (movePoint2>-1){
			moveNode1 = fixChildNodes[movePoint2];
		}
		moveNode2 = fixChildNodes[movePoint1];
	}else if (type==3){
		//移动到下一个同级节点
		movePoint2++;
		if (movePoint2<childNodeCount){
			moveNode1 = fixChildNodes[movePoint2];
		}
		moveNode2 = fixChildNodes[movePoint1];
	}
	
	//清空父节点中的内容
	parentNode.innerHTML = "";
	
	if (type==1){
		//插入节点开头
		try{
			parentNode.appendChild(cloneAllNode(moveNode));
		}catch(e){}
	}
	var i=0; //循环变量
	while(i<childNodeCount){

		try{
			if (moveNode1==null || moveNode2==null){
				parentNode.appendChild(cloneAllNode(fixChildNodes[i]));
			}else{
				if (type==2 || type==3){
					if (i==movePoint1){
						parentNode.appendChild(cloneAllNode(moveNode1));
					}else if (i==movePoint2){
						parentNode.appendChild(cloneAllNode(moveNode2));
					}else{
						parentNode.appendChild(cloneAllNode(fixChildNodes[i]));
					}
				}else{
					parentNode.appendChild(cloneAllNode(fixChildNodes[i]));
				}
			}
		}catch(e){}
		i++;
	}
	if (type==2){
		//父节点末尾
		try{
			parentNode.appendChild(cloneAllNode(moveNode));
		}catch(e){}
	}
}

/**
 * 在指定节点的父节点中插入制定节点
 * JavaScript中自带的方法执行后，输出的HTML格式是错误的
 * thisNodeOrId 指定节点或节点主键
 * newNode 待插入节点
 * type 0父节点的开头位置 1父节点的末尾 2指定节点的上方 3指定节点的下方
 * isParentNode 第一个参数是否为父类 该参数只能用在 type为0 或 1时
 */
function insertNode(thisNodeOrId,newNode,type,isParentNode){
	var thisNode = getNodeByObject(thisNodeOrId); //获取节点
	if (thisNode==null || newNode==null){
		return;
	}
	if (type==null){
		type = 0;
	}
	if (type!=0 && type!=1){
		isParentNode = false;
	}
	//获取父节点
	var parentNode = null;
	if (isParentNode){
		parentNode = thisNode;
	}else{
		parentNode = thisNode.parentNode;
	}

	//获取父节点下的子节点
	var childNodes = null;
	try{
		childNodes = parentNode.childNodes;
	}catch(e){}

	var thisNodePoint = 0; //指定节点在父节点中的位置
	if (!isParentNode && childNodes!=null){
		//如果第一个参数是父节点，此动作不必做，做了也白做，自己是不能在自己的子节点中
		while(childNodes[thisNodePoint]!=thisNode){
			thisNodePoint++;
		}
	}
	//获取克隆后的子节点
	var fixChildNodes = null;
	try{
		fixChildNodes = cloneAllNode(parentNode).childNodes;
	}catch(e){}
	var childNodeCount = 0;
	if (fixChildNodes!=null){
		childNodeCount = fixChildNodes.length; //子节点总数
	}
	//清空父节点中的内容
	parentNode.innerHTML = "";
	
	if (type==0){
		//父节点开头
		try{
			parentNode.appendChild(newNode);
		}catch(e){}
	}
	var i=0; //循环变量
	while(i<childNodeCount){
		
		try{
			if (!isParentNode){
				if (i==thisNodePoint){
					if (type==2){
						//指定节点前
						parentNode.appendChild(newNode);
						parentNode.appendChild(cloneAllNode(fixChildNodes[i]));
						i++;
						continue;
					}else if (type==3){
						//指定节点后
						parentNode.appendChild(cloneAllNode(fixChildNodes[i]));
						parentNode.appendChild(newNode);
						i++;
						continue;
					}
				}
			}
			parentNode.appendChild(cloneAllNode(fixChildNodes[i]));
		}catch(e){}
		i++;
	}
	if (type==1){
		//父节点末尾
		try{
			parentNode.appendChild(newNode);
		}catch(e){
			alert(e.description);
		}
	}
}

/**
 * 处理字符串序列
 * allArrayListString 源字符串序列
 * elementString 待处理的字符串元素
 * type 0累加 1减去
 */
function fixArrayListString(allArrayListString,elementString,type){
	
	if (allArrayListString==null){
		allArrayListString = "";
	}
	if (elementString==null){
		elementString = "";
	}
	if (type==0){
		if (allArrayListString.length>0){
			return allArrayListString+","+elementString;
		}
		return elementString;
	}else if (type==1){
		var arrs = allArrayListString.split(",");
		var reStr = "";
		var i = 0;
		var j = 0;
		while(i<arrs.length){
			
			if (arrs[i]==elementString){
				i++;
				continue;
			}
			
			if (j>0){
				reStr += ",";
			}
			reStr += arrs[i];
			j++;
			i++;
		}
		return reStr;
	}
	return allArrayListString;
}


/**
 * 序列容器
 */
function ValueList(){

	var listValue = []; //核心容器
	
	this.typeName = "List"; //容器名称
	this.size = getSize; //容器元素数量方法
	this.add = addElement; //增加元素方法
	this.removeByElement = removeByElement; //移除指定元素
	this.removeByIndex = removeByIndex; //通过索引移除指定元素
	this.get = getElement; //获取指定元素
	this.contains = containsElement; //判断指定元素是否存在于序列中
	this.clearAll = clearAll; //清空所有元素
	this.getList = getElementList; //获取元素数组
	this.getListString = getElementString; //获取元素字符串序列
	this.toJavaString = getJavaString; //获取提交java类的字符串信息
	this.toEncodeJavaString = getEncodeJavaString; //获取编码后的提交java类的字符串信息
	
	/**
	 * 返回容器元素数量
	 * @return 回容器元素数量
	 */
	function getSize(){
		return listValue.length;
	}
	
	/**
	 * 获取提交java类的字符串信息
	 * @return 提交java类的字符串信息
	 */
	function getJavaString(){
		return getObjectJavaString(this);
	}
	
	
	/**
	 * 获取提交java类的字符串信息
	 * @return 提交java类的字符串信息
	 */
	function getEncodeJavaString(){
		return URLEncodePro(getObjectJavaString(this));
	}
	
	/**
	 * 清空所有元素
	 */
	function clearAll(){
		listValue = [];
	}
	
	/**
	 * 增加元素
	 * @param element 增加的元素
	 * @param index 增加到的位置
	 */
	function addElement(element,index){
	
		if (index==null || index==""){
			listValue[listValue.length] = element;
			return;
		}
		var indexInt; //获取指定索引位置数字
		try{
			indexInt = new Number(index);
		}catch(e){
			return;
		}
		if (indexInt<0){
			return;
		}
		//将指定位置之后的元素后遗
		var i =listValue.length; //循环索引
		while(i>indexInt){
			listValue[i] = listValue[i-1];
			i--;
		}
		listValue[indexInt] = element;
	}
	
	/**
	 * 移除指定的元素
	 * 如果容器中有相同的元素存在
	 * 则只移除需要由小到大头一个相同的元素
	 * @param element 指定的元素
	 */
	function removeByElement(element){
		
		var afterRemoveList = []; //移除元素后的容器
		var i = 0; //循环变量
		while(i<listValue.length){
			
			if (listValue[i]==element){
				i++;
				continue;
			}
			afterRemoveList[afterRemoveList.length]=listValue[i];
			i++;
		}
		listValue = afterRemoveList;
	}
	
	/**
	 * 通过元素序号移除指定元素
	 * @param index 元素序号
	 */
	function removeByIndex(index){
		
		//元素索引数字
		var indexInt;
		try{
			indexInt = new Number(index);
		}catch(e){
			return;
		}
		var afterRemoveList = []; //移除元素后的容器
		var i = 0; //循环变量
		while(i<listValue.length){
			
			if (i==indexInt){
				i++;
				continue;
			}
			afterRemoveList[afterRemoveList.length]=listValue[i];
			i++;
		}
		listValue = afterRemoveList;
	}
	
	/**
	 * 获取元素值
	 * @param index 元素索引
	 * @return 返回对应元素
	 */
	function getElement(index){
	
		//元素索引数字
		var indexInt;
		try{
			indexInt = new Number(index);
		}catch(e){
			return null;
		}
		try{
			return listValue[index];
		}catch(e){
			return null;
		}
	}
	
	/**
	 * 判断元素是否存在与序列中
	 * @param element 带判断元素
	 * @return tree存在与序列中
	 */
	function containsElement(element){
		
		var i=0; //循环变量
		while(i<listValue.length){
			if (listValue[i]==element){
				return true;
			}
			i++;
		}
		return false;
	}
	
	/**
	 * 获取元素数组
	 * @return 元素数组
	 */
	function getElementList(){
		return listValue;
	}
	
	
	/**
	 * 获取元素字符串序列
	 * @return 元素字符串序列
	 */
	function getElementString(){
		
		//返回值
		var reStr = "";
		var i=0; //循环变量
		while(i<listValue.length){
			if (i>0){
				reStr += ",";
			}
			if (listValue[i]!=null){
				reStr += listValue[i];
			}
			i++;
		}
		return reStr;
	}
}


/**
 * 主键值容器
 */
function ValueMap(){
		
	var keyList = new ValueList(); //主键序列
	var vMap = ({}); //值容器
	
	this.typeName = "Map"; //容器名称
	this.put = doPut; //设置值
	this.get = doGet; //获取值
	this.clear = doClear; //清除所有值
	this.getKeys = doGetKeys; //获取所有值主键数组
	this.remove = doRemove; //移除指定值
	this.getKeyString = doGetKeyString; //获取主键字符串
	this.getKeyList = doGetKeyList; //获取主键序列
	this.toJavaString = getJavaString; //获取提交java类的字符串信息
	this.toEncodeJavaString = getEncodeJavaString; //获取编码后的提交java类的字符串信息
	this.size = keyList.size; //容器中元素数量
	
	/**
	 * 获取编码后的提交java类的字符串信息
	 * @return 提交java类的字符串信息
	 */
	function getEncodeJavaString(){
		return URLEncodePro(getObjectJavaString(this));
	}
	
	/**
	 * 获取提交java类的字符串信息
	 * @return 提交java类的字符串信息
	 */
	function getJavaString(){
		return getObjectJavaString(this);
	}
	
	/**
	 * 移除主键值
	 * @param key 主键
	 */
	function doRemove(key){
		vMap[key] = null;
		if (keyList.contains(key)){
			keyList.removeByElement(key);
		}
	}
	
	/**
	 * 获取容器主键数组
	 * @return 主键数组
	 */
	function doGetKeys(){
		return keyList.getList();
	}
	
	/**
	 * 获取主键序列
	 * @return 主键序列
	 */
	function doGetKeyList(){
		return keyList;
	}
	
	/**
	 * 清除内容
	 */
	function doClear(){
		keyList.clearAll();
		vMap = ({});
	}
	/**
	 * 将值放入容器
	 * @param key 主键
	 * @param value 值
	 */
	function doPut(key,value){
		vMap[key] = value;
		if (!keyList.contains(key)){
			keyList.add(key);
		}
	}
	
	/**
	 * 取出指定值
	 * @param key 主键
	 * @return 对应值
	 */
	function doGet(key){
		var reValue = vMap[key];
		if (reValue==null){
			reValue = "";
		}
		return reValue;
	}
	
	/**
	 * 获取主键字符串
	 * @return 主键字符串
	 */
	function doGetKeyString(){
		return keyList.getListString();
	}
}


/**
 * 将对象值转换为要发送到JAVA的字符串 (递归函数)
 * 总长度;元素1长度,元素2长度;元素1元素2
 * @param 待转换的对象
 * @return 要发送到JAVA的字符串
 */
function getObjectJavaString(object){

	if (object == null){
		return "";
	}
	//获取对象类型
	var typeName = object.typeName;
	if (typeName==null){
		//默认为字符串
		return object;
	}else if (typeName=="List"){
		var reValueStr = ""; //构造返回值内容
		var reSizeStr = ""; //构造返回值长度信息
		var elementStr; //元素字符串信息值
		var i=0; //循环变量
		while(i<object.size()){
			//获取元素字符串信息值
			if (i>0){
				reSizeStr += ",";
			}
			elementStr = getObjectJavaString(object.get(i));
			if (elementStr==null){
				elementStr = "";
			}
			reValueStr += elementStr;
			reSizeStr += doubleCharLength(elementStr);
			i++;
		}
		var elementString = reSizeStr+";"+reValueStr; //构造元素信息值
		elementString = doubleCharLength(elementString)+";"+elementString;
		
		//构造返回值
		var reStr = "19,"+doubleCharLength(elementString)+";java.util.ArrayList"+elementString;
		return doubleCharLength(reStr)+";"+reStr; 
	}else if (typeName=="Map"){
	
		var valueValueStr = ""; //值信息
		var valueSizeStr = ""; //值长度
		var valueStr; //元素字符串信息值
		var keyList = object.getKeyList(); //获取主键序列
		var i=0; //循环变量
		while(i<keyList.size()){
			//获取值字符串信息
			valueStr = getObjectJavaString(object.get(keyList.get(i)));
			if (i>0){
				valueSizeStr += ",";
			}
			if (valueStr==null){
				valueStr = "";
			}
			valueValueStr += valueStr;
			valueSizeStr += doubleCharLength(valueStr);
			i++;
		}
		//获取主键字符串信息
		var keyString = getObjectJavaString(keyList);
		var valueString = valueSizeStr+";"+valueValueStr;
		valueString = doubleCharLength(valueString)+";"+valueString;
		valueString = "19,"+doubleCharLength(valueString)+";java.util.ArrayList"+valueString;
		valueString = doubleCharLength(valueString)+";"+valueString;
		//构造返回值
		var reStr = "17,"+doubleCharLength(keyString)+","+doubleCharLength(valueString)+";java.util.HashMap"+keyString+valueString;
		return doubleCharLength(reStr)+";"+reStr;
	}
}


/**
 * 将源form中要提交的的内容复制到目标form中
 * 通常用于普通Form方式提交多个form中的内容
 * srcFormOrId 源form或form主键
 * objFormOrId 目标form或form主键
 * notFirst递归调用时使用（内部调用参数）
 */
function copyFormDataToOtherForm(srcFormOrId,objFormOrId,notFirst){

	var srcTag = getNodeByObject(srcFormOrId); //源标签
	var objTag = getNodeByObject(objFormOrId); //复制到的目标标签
	if (srcTag==null || objTag==null){
		return objTag;
	}
	if (notFirst==null){
		var newSrcTag = document.createElement("div");
		newSrcTag.innerHTML = srcTag.innerHTML;
		srcTag = newSrcTag;
	}
	var nodeName = getNodeName(srcTag); //节点名
	if (nodeName=="INPUT" || nodeName=="TEXTAREA" || nodeName=="SELECT"){
		//获取输入类型属性
		var typeAttrilb = getNodeAttribute(srcTag,"type").toLowerCase();
		if (typeAttrilb=='button'){
			//不提交按钮信息
			return objTag;
		}
		try{
			//放入克隆后的标签
			insertNode(objTag,srcTag.cloneNode(),1,true);
		}catch(e){}
	}else{
		var clds;
		try{
			clds = srcTag.children;
		}catch(e){}
		if (clds!=null && clds.length>0){
			var i=0;
			while(i<clds.length){
				objTag = copyFormDataToOtherForm(clds[i],objTag,true);
				i++;
			}
		}
	}
	return objTag;
}

/**
 * 去字符串两侧空格
 */
function trim(s){
	return rtrim(ltrim(s));
}


/**
 * 去字符串左侧空格
 */
function ltrim(s){
	return s.replace( /^\s*/, "");
}
/**
 * 去字符串右侧空格
 */
function rtrim(s){
	return s.replace( /\s*$/, "");
}

/**
 * 检测密码强度
 * 密码过短返回0
 * 1种组合返回1
 * 2种组合返回2
 * 3种组合返回3
 * 4种组合返回4
 */
function checkPassword(pwd){
	return pwd.replace(/^(?:([a-z])|([A-Z])|([0-9])|(.)){5,}|(.)+$/g, "$1$2$3$4$5").length;
}





/**
 *  创建XMLHTTPRequest对象
 */
function getXMLHttp() { 
	var oXML = null; 
	// 开始初始化XMLHttpRequest对象 
	if(window.XMLHttpRequest) { 
		// Mozilla 浏览器 
		oXML = new XMLHttpRequest(); 
		if (oXML.overrideMimeType){ 
			// 设置MiME类别 
			oXML.overrideMimeType('text/xml'); 
		} 
		return oXML; 
	}else if (window.ActiveXObject){ 
		// IE浏览器 
		try { 
			oXML = new ActiveXObject("Msxml2.XMLHTTP"); 
		} catch (e) { 
			try { 
				oXML = new ActiveXObject("Microsoft.XMLHTTP"); 
			} catch (e) {} 
		} 
	} 
	
	if (!oXML){ 
		// 异常，创建对象实例失败 
		window.alert("不能创建XMLHttpRequest对象实例."); 
		return false; 
	} 
	return oXML; 
} 

/**
 * http://developer.mozilla.org/en/docs/DOMParser
 * 接受一段xml，解析成为xml document对象
 * 调用时可用try{}catch(e){}捕捉错误，错误对象具有parser xml message属性
 * @param {String} xml string
 * @return {Object} xml document object
 */
function xmlDocument(/* String */xmlString){
    var doc = null;
    if (window.ActiveXObject){
        var ActiveIds = ['MSXML2.XMLDOM', 'Microsoft.XMLDOM', 'MSXML.XMLDOM', 'MSXML3.XMLDOM'];
        for (var len = ActiveIds.length, i = 0; i < len; i++){
            var id = ActiveIds[i];
            try{
                var doc = new ActiveXObject(id);
                doc.async = false;
                doc.setProperty('SelectionLanguage', 'XPath');
                doc.loadXML(xmlString);
                return doc;
            }catch (e){}
        }
    }else if (typeof DOMParser != 'undefined'){
        var parser = new DOMParser();
        var doc = parser.parseFromString(xmlString, 'text/xml');
        if (doc.documentElement.nodeName == 'parsererror'){
            return null;
        }
    }
    return doc;
}

/**
 * 获取指定节点或文档对象的xml内容
 * port from ajaxslt xmlText()
 * @param {Object} xml DOM Node or xml Document
 * @return {String} xml string
 */
function xmlText(/* Document|Element */node){
    if (typeof node == 'string'){ return node; }

    if (node.innerXML){
        return node.innerXML;
    }else if (node.xml){
        return node.xml;
    }else if (typeof XMLSerializer != 'undefined'){
        return (new XMLSerializer()).serializeToString(node);
    }else{ return false; }
}

/**
 * 获取所有节点的内容
 * port from ajaxslt xmlValue()
 * @param {Object} xml DOM Node or xml Document
 * @return {String}
 */
function xmlValue(/* Document|Element */node){
    var val = '';
    if (node.nodeType == DOM_TEXT_NODE ||
        node.nodeType == DOM_CDATA_SECTION_NODE ||
        node.nodeType == DOM_ATTRIBUTE_NODE){
        val += node.nodeValue;
    }else if (node.nodeType == DOM_ELEMENT_NODE ||
              node.nodeType == DOM_DOCUMENT_NODE ||
              node.nodeType == DOM_DOCUMENT_FRAGMENT_NODE){
        for (var len = node.childNodes.length, i = 0; i < len; i++){
            val += arguments.callee(node.childNodes[i]);
        }
    }
    return val;
}


/**
 * 获取节点属性，以对象形式返回
 * @param {Object}
 * @return {Object}
 */
function xmlGetAttributes(/* Element */node){
    var result = {};
    var nodeMap = node.attributes;
    if (nodeMap){
        for (var len = nodeMap.length, i = 0; i < len; i++){
            var aNode = nodeMap.item(i);
            result[aNode.nodeName] = aNode.nodeValue;
        }
    }
    return result;
}


/**
 * 获取指定属性
 * node 指定节点
 * key 属性名
 */
function xmlGetAttribute(node,key){
	try{
		return xmlGetAttributes(node)[key];
	}catch(e){}
	return "";
}

/**
 * 频道项
 */
function rssItem(){
	
	var cTitle; 		//频道项标题
	var cLink; 			//频道项链接
	var cAuthor; 		//频道项作者
	var cGuid; 			//频道项guid
	var cPubdate; 		//发布时间
	var cComments; 		//评论
	var cDescription; 	//说明
	var cSourceTitle; 	//信息标题
	var cSourceUrl; 	//信息链接
	var itemXmlDoc;			//xml对象
	
	this.setItem = doSetItem;				//设置频道项对象 传入频道项xml对象
	this.getTitle = doGetTitle; 			//获取频道项标题
	this.getLink = doGetLink;				//获取频道项链接
	this.getAuthor = doGetAuthor;			//获取频道项作者
	this.getGuid = doGetGuid;				//获取频道项guid
	this.getPubdate = doGetPubdate;			//获取频道项发布时间
	this.getComments = doGetComments;		//获取频道项评论
	this.getDescription = doGetDescription;	//获取频道项说明
	this.getSourceTitle = doGetSourceTitle; //获取信息标题
	this.getSourceUrl = doGetSourceUrl; 	//获取信息链接
	this.getInfo = doGetInfo;				//获取频道其它信息 infoKey 信息主键 节点名
	
	/**
	 * 获取信息链接
	 */
	 function doGetSourceUrl(){
	 	 return cSourceUrl;
	 }
	 
	/**
	 * 获取信息标题
	 */
	 function doGetSourceTitle(){
	 	 return cSourceTitle;
	 }
	 
	/**
	 * 获取频道项说明
	 */
	 function doGetDescription(){
	 	 return cDescription;
	 }
	 
	/**
	 * 获取频道项评论
	 */
	 function doGetComments(){
	 	 return cComments;
	 }
	 
	/**
	 * 获取频道项发布时间
	 */
	 function doGetPubdate(){
	 	 return cPubdate;
	 }
	 
	/**
	 * 获取频道项guid
	 */
	 function doGetGuid(){
	 	 return cGuid;
	 }
	 
	/**
	 * 获取频道项作者
	 */
	 function doGetAuthor(){
	 	 return cAuthor;
	 }
	 
	/**
	 * 获取频道项链接
	 */
	 function doGetLink(){
	 	 return cLink;
	 }
	 
	/**
	 * 获取频道项标题
	 */
	function doGetTitle(){
		return cTitle;
	}

	/**
	 * 获取其它频道信息
	 * infoKey 信息主键 节点名
	 */
	function doGetInfo(infoKey){
		try{
			return itemXmlDoc.getElementsByTagName(infoKey)[0].text;
		}catch(e){}
		return "";
	}
	
	/**
	 * 设置频道项对象
	 * xmlDoc 传入频道项xml对象
	 */
	function doSetItem(xmlDoc){
		itemXmlDoc = xmlDoc;
		try{
			cTitle = xmlDoc.getElementsByTagName("title")[0].text;
		}catch(e){}
		try{
			cLink = xmlDoc.getElementsByTagName("link")[0].text;
		}catch(e){}
		try{
			cAuthor = xmlDoc.getElementsByTagName("author")[0].text;
		}catch(e){}
		try{
			cGuid = xmlDoc.getElementsByTagName("guid")[0].text;
		}catch(e){}
		try{
			cPubdate = xmlDoc.getElementsByTagName("pubdate")[0].text;
		}catch(e){}
		try{
			cComments = xmlDoc.getElementsByTagName("comments")[0].text;
		}catch(e){}
		try{
			cDescription = xmlDoc.getElementsByTagName("description")[0].text;
		}catch(e){}
		try{
			cSourceTitle = xmlDoc.getElementsByTagName("source")[0].text;
		}catch(e){}
		try{
			cSourceUrl = xmlGetAttribute(xmlDoc.getElementsByTagName("source")[0],"url");
		}catch(e){}
	}
}


/**
 * RSS频道信息
 */
function rssChannel(){

	var cTitle; 					//频道标题
	var cLink; 						//频道链接
	var cDescription; 				//频道说明
	var cLanguage; 					//语言
	var cGenerator; 				//来源
	var cCopyright; 				//获取版权信息
	var channelXmlDoc;						//XML对象
	var itemList = new ValueList(); //频道信息序列
	
	this.setChannel = doSetChannel; 		//设置频道对象 传入频道xml对象
	this.getTitle =doGetTitle; 				//获取频道标题
	this.getLink = doGetLink; 				//获取频道链接
	this.getDescription = doGetdescription; //获取频道说明
	this.getLanguage = doGetLanguage; 		//获取频道语言
	this.getGenerator = doGetGenerator; 	//获取频道来源
	this.getCopyright = doGetCopyright; 	//获取频道版权信息
	this.getItem = itemList.get;			//获取指定项 传入频道项索引
	this.itemSize = itemList.size;			//获取频道项数
	this.getInfo = doGetInfo;				//获取频道其它信息 infoKey 信息主键 节点名
	
	/**
	 * 获取版权信息
	 */
	function doGetCopyright(){
		return cCopyright;
	}
	
	/**
	 * 获取来源
	 */
	 function doGetGenerator(){
	 	 return cGenerator;
	 }
	 
	/**
	 * 获取语言
	 */
	function doGetLanguage(){
		return cLanguage;
	}
	
	/**
	 * 获取说明
	 */
	 function doGetdescription(){
	 	 return cDescription;
	 }
	 
	/**
	 * 获取频道链接
	 */
	function doGetLink(){
		return cLink;
	}
	
	/**
	 * 获取频道标题
	 */
	function doGetTitle(){
		return cTitle;
	}
	
	/**
	 * 获取其它频道信息
	 * infoKey 信息主键 节点名
	 */
	function doGetInfo(infoKey){
		try{
			return channelXmlDoc.getElementsByTagName(infoKey)[0].text;
		}catch(e){}
		return "";
	}
	
	/**
	 * 设置频道标题
	 */
	function doSetChannel(xmlDoc){
		channelXmlDoc = xmlDoc;
		try{
			cTitle = xmlDoc.getElementsByTagName("title")[0].text;
		}catch(e){}
		try{ 
			cLink = xmlDoc.getElementsByTagName("link")[0].text;
		}catch(e){}
		try{ 
			cLink = xmlDoc.getElementsByTagName("description")[0].text;
		}catch(e){}
		try{ 
			cLanguage = xmlDoc.getElementsByTagName("language")[0].text;
		}catch(e){}
		try{ 
			cGenerator = xmlDoc.getElementsByTagName("generator")[0].text;
		}catch(e){}
		try{ 
			cCopyright = xmlDoc.getElementsByTagName("copyright")[0].text;
		}catch(e){}
		
		//获取频道项数组
		var itemXmls = xmlDoc.getElementsByTagName("item");
		if (itemXmls==null){
			return;
		}
		
		//循环处理频道项
		for(var i=0;i<itemXmls.length;i++){
			if (itemXmls[i]==null){
				continue;
			}
			var item = new rssItem(); //构建新的频道项对象
			item.setItem(itemXmls[i]); //设置频道段
			itemList.add(item); //放入序列
		}
	}
	
	
}
/**
 * 获取Rss记录集
 * rssStr Rss信息
 */
function getRssRescordSet(rssStr){

	var channelList = new ValueList(); //频道信息序列
	
	this.get = channelList.get; //获取指定频道
	this.size = channelList.size; //频道数
	
	var xmlDoc = xmlDocument(rssStr); //解析xml内容
	if (xmlDoc==null){
		return;
	}
	
	//获取频道数组
	var channelXmls = xmlDoc.getElementsByTagName("channel");
	if (channelXmls==null){
		return;
	}
	
	//循环处理频道
	var ii = 0;
	while(ii<channelXmls.length){
		var i = ii;
		ii++;
		if (channelXmls[i]==null){
			continue;
		}
		
		var rssC = new rssChannel(); //构建新的频道对象
		
		rssC.setChannel(channelXmls[i]); //设置频道段
		
		channelList.add(rssC); //放入序列
	}
}


/**
 * 调用动作，将结果设置到指定标签中
 * action 动作路径
 * data 传送数据
 * areaNodeOrId 显示区域对象或主键
 */
function callAction(action,data,areaNodeOrId,isAppend,debugNode){
	
	var actionReq = getXMLHttp(); //构建获取数据方法
	
	actionReq.onreadystatechange = function() {

		if(actionReq.readyState == 4){

			if (actionReq.status < 400) {
				
				var resValue = actionReq.responseText; //返回值
				if (debugNode!=null){
					try{
						debugNode = getNodeByObject(debugNode);
						debugNode.innerText += "\n\n<br/><br/>\n\n"+resValue;
					}catch(e){}
				}
				var scriptNodes = getNodeElementsByNodeName(thisNode,"script");
				if (scriptNodes!=null){
					for(var i=0;i<scriptNodes.length;i++){
						if (scriptNodes[i]==null){
							continue;
						}
						try{
							eval(scriptNodes[i].text);
						}catch(e){}
					}
				}
				try{
					if (isAppend){
						insertNode(getNodeByObject(areaNodeOrId),thisNode,1,true);
					}else{
						getNodeByObject(areaNodeOrId).innerHTML = thisNode.innerHTML;
					}
				}catch(e){}
			}else{
				if (debugNode!=null){
					var errorMsg = "\n\n<br/><br/>\n\nRunAction:"+action+"\n<br/>"+actionReq.responseText;
					alert(errorMsg);
					try{
						debugNode = getNodeByObject(debugNode);
						debugNode.innerText += errorMsg;
					}catch(e){}
				}
			}
		}
	}
	dataReq.open("POST",action, false);
	dataReq.setRequestHeader("CONTENT-TYPE","application/x-www-form-urlencoded");
	dataReq.send(data);
}


/**
 * 获取页面内容
 * action 动作路径
 * data 提交数据
 * 不返回错误信息
 */
function getHttpText(action,data,noError){

	var dataReq = getXMLHttp(); //构建获取数据方法
	var res = null;
	dataReq.onreadystatechange = function() {
	
		if(dataReq.readyState == 4){
			if (dataReq.status < 400) {
				res = dataReq.responseText;
			}else {
				if (!noError){
					res = dataReq.responseText;
				}
			}
		}
	}
	dataReq.open("POST",action, false);
	dataReq.setRequestHeader("CONTENT-TYPE","application/x-www-form-urlencoded");
	dataReq.send(data);
	return res;
}


/**
 * 调用Rss信息显示到页面中
 * action 获取数据动作路径
 * htmlUrl 模板路径
 * areaNodeOrId 显示区域对象或主键
 * isAppend 是否在区域中添加
 */
function callRssShow(action,data,htmlUrl,areaNodeOrId,isAppend,debugNode){
	if (htmlUrl==null){
		callAction(action,data,areaNodeOrId,isAppend,debugNode);
		return;
	}
	var dataReq = getXMLHttp(); //构建获取数据方法

	dataReq.onreadystatechange = function() {

		if(dataReq.readyState == 4){

			if (dataReq.status < 400) {
				var resValue = dataReq.responseText; //返回值
				if (debugNode!=null){
					try{
						debugNode = getNodeByObject(debugNode);
						debugNode.innerText += "\n\n<br/><br/>\n\n"+resValue;
					}catch(e){}
				}
				var rssRs = new getRssRescordSet(resValue); //获取记录集对象
				var htmlReq = getXMLHttp(); //构建获取模板方法
				
				htmlReq.onreadystatechange = function() {

					if(htmlReq.readyState == 4){

						if (htmlReq.status < 400) {
							var htmlResValue = htmlReq.responseText; //返回值
							var thisNode = document.createElement("SPAN");
							thisNode.innerHTML = htmlResValue; //设置标签内容
							var scriptNodes = getNodeElementsByNodeName(thisNode,"script");
							try{
								eval(scriptNodes[0].text);
							}catch(e){}
							try{
								if (isAppend){
									insertNode(getNodeByObject(areaNodeOrId),thisNode,1,true);
								}else{
									getNodeByObject(areaNodeOrId).innerHTML = thisNode.innerHTML;
								}
							}catch(e){}
						}else{
							if (debugNode!=null){
								var errorStr = "\n\n<br/><br/>\n\nRunAction:"+htmlUrl+"\n<br/>"+htmlReq.responseText;
								alert(errorStr);
								try{
									debugNode = getNodeByObject(debugNode);
									debugNode.innerText += errorStr;
								}catch(e){}
							}
						}
					}
				}
				htmlReq.open("POST",htmlUrl, false);
				htmlReq.setRequestHeader("CONTENT-TYPE","application/x-www-form-urlencoded");
				htmlReq.send("");
			}else{
				if (debugNode!=null){
					var errorStr = "\n\n<br/><br/>\n\nRunAction:"+action+"\n<br/>"+dataReq.responseText;
					alert(errorStr);
					try{
						debugNode = getNodeByObject(debugNode);
						debugNode.innerText += errorStr;
					}catch(e){}
				}
			}
		}
	}
	dataReq.open("POST",action, false);
	dataReq.setRequestHeader("CONTENT-TYPE","application/x-www-form-urlencoded");
	dataReq.send(data);
}

/**
 * 设置表格数据
 * rssRs 记录集
 * tableOrId 表格对象
 * trId 行主键
 * noDataId 没有数据提示行主键
 * otherIDs 其它数据/标签主键数组
 */
function setDetailValue(channelRss,areaOrId,tableId,trId,noDataId,otherIDs){
	//构建区域对象
	var areaNode = getNodeByObject(areaOrId);
	//获取表对象
	var tableNode = getNodeElementById(areaNode,tableId);
	if (tableNode==null){
		try{
			removeNodeByAttribute(tableNode,"id",trId);
		}catch(e){}
		return;
	}
	if (channelRss==null){
		try{
			removeNodeByAttribute(tableNode,"id",trId);
		}catch(e){}
		return;
	}
	var cTitleNode = getNodeElementById(areaNode,"ctitle");
	if (cTitleNode!=null){
		fixType(cTitleNode,channelRss.getTitle());
		if (cTitleNode.getAttribute("href")!=null){
			try{
				cTitleNode.setAttribute(channelRss.getLink());
			}catch(e){}
		}
	}
	if (tableId==null || trId==null){
		try{
			removeNodeByAttribute(tableNode,"id",trId);
		}catch(e){}
		return;
	}
	var trModel; //行模板
	if (channelRss.itemSize()>0){
		if (noDataId!=null){
			removeNodeByAttribute(tableNode,"id",noDataId);
		}
		//获取行模板
		var trRes = getNodeElementById(tableNode,trId);
		//克隆行模板
		var trModel = cloneAllNode(trRes);
		removeNodeByAttribute(tableNode,"id",trId);
	}else{
		removeNodeByAttribute(tableNode,"id",trId);
	}

	for(var i=0;i<channelRss.itemSize();i++){
		var itemRss = channelRss.getItem(i); //获取行记录集
		var trObj = cloneAllNode(trModel); //构建行模板
		
		//文章题目
		var sourceNode = getNodeElementById(trObj,"source");
		if (sourceNode!=null){
			fixType(sourceNode,itemRss.getSourceTitle());
			sourceNode.setAttribute("href",itemRss.getSourceUrl());
		}
		var issDateNode = getNodeElementById(trObj,"issdate");
		if (issDateNode!=null){
			fixType(issDateNode,itemRss.getInfo("issdate"));
		}
		if (otherIDs!=null){
			for(var j=0;j<otherIDs.length;j++){
				var ele = getNodeElementById(trObj,otherIDs[j]);
				if (ele==null){
					continue;
				}
				fixType(ele,itemRss.getInfo(otherIDs[j]));
			}
		}
		//发布时间
		insertNode(tableNode,trObj,1,true);
	}
}


/**
 * 通过标签属性处理结果值
 * 指定标签
 * 结果值
 */
function fixType(nodeOrId,fixValue){
	
	//构建指定节点
	var node = getNodeByObject(nodeOrId);
	if (node==null){
		return;
	}
	//获取检测类型
	var type = getNodeAttribute(node,ATTRIBUTE_FIX_TYPE);
	if (type!=""){
		if (type=="date"){
			if (fixValue.length>=10){
				fixValue = fixValue.substring(0,10);
			}
		}else if (type=="time"){
			if (fixValue.length>=19){
				fixValue = fixValue.substring(11,19);
			}
		}else if (type=="datemd"){
			if (fixValue.length>=10){
				fixValue = fixValue.substring(5,10);
			}
		}else if (type.indexOf("cut")==0){
			var cutNum = type.substring(3,type.length);
			try{
				if (fixValue.length>cutNum){
					fixValue = fixValue.substring(0,cutNum)+"...";
				}
			}catch(e){}
		}
	}
	if (node.nodeName=="INPUT" || node.nodeName=="SELECT"){
		node.value = fixValue;
	}else{
		node.innerText = fixValue;
	}
}


/**
 * 显示用户自定义页面
 * compDataUrl 获取加载组件信息动作路径
 * debugNode 调试节点
 */
function showComponentPage(compDataUrl,debugNode){
	
	if (compDataUrl==null){
		return;
	}
	var dataReq = getXMLHttp(); //构建获取数据方法

	dataReq.onreadystatechange = function() {

		if(dataReq.readyState == 4){

			if (dataReq.status < 400) {
				
				var resValue = dataReq.responseText; //返回值
				if (debugNode!=null){
					try{
						debugNode = getNodeByObject(debugNode);
						debugNode.innerText += "\n\n<br/><br/>\n\n"+resValue;
					}catch(e){}
				}
				var compVO = new getAreaComponentValueObject(resValue); //获取数据

				var ii=0;
				while(ii<compVO.size()){
					var i=ii;
					ii++;

					var areaVO = compVO.get(i); //获取区域容器
					//获取区域名称
					var areaID = areaVO.getName();
					//循环处理该区域组件
					var j = 0;
					while(j<areaVO.size()){
						//获取组件元素
						var comp = areaVO.get(j);
						//显示板块
						callRssShow(comp.getAction(),comp.getModelUrl(),areaID,true,debugNode);
						j++;
					}
				}
			}else{
				if (debugNode!=null){
					var errorStr = "\n\n<br/><br/>\n\nRunAction:"+compDataUrl+"\n<br/>"+dataReq.responseText;
					alert(errorStr);
					try{
						debugNode = getNodeByObject(debugNode);
						debugNode.innerText += errorStr;
					}catch(e){}
				}
			}
		}
	}
	dataReq.open("POST",compDataUrl, false);
	dataReq.setRequestHeader("CONTENT-TYPE","application/x-www-form-urlencoded");
	dataReq.send("");
}

/**
 * 组件信息容器
 */
function getAreaComponentValueObject(xmlData){
	
	var areaList = new ValueList(); //区域序列

	this.get = areaList.get; //获取指定区域信息
	this.size = areaList.size; //区域数量
	
	var xmlDoc = xmlDocument(xmlData); //解析xml内容
	if (xmlDoc==null){
		return;
	}
	//获取区域信息块
	var areaXmls = xmlDoc.getElementsByTagName("areaset");
	if (areaXmls==null){
		return;
	}
	//循环处理区域
	var ii=0;
	while(ii<areaXmls.length){
		var i=ii;
		ii++;
		if (areaXmls[i]==null){
			continue;
		}
		var areaVO = new AreaValueObject(); //构建新的区域块
		areaVO.setData(areaXmls[i]); //设置区域数据
		areaList.add(areaVO); //放入序列
	}
}


/**
 * 区域信息容器
 */
function AreaValueObject(){
	
	var cName; //区域名称
	var areaXmlDoc; //区域xml对象
	var compList = new ValueList(); //组件序列
	
	this.get = compList.get;  //获取指定组件
	this.size = compList.size;  //获取组件数量
	this.setData = doSetData; //设置信息
	this.getName = doGetName; //获取区域名
	
	/**
	 * 获取区域名称
	 */
	function doGetName(){
		return cName;
	}
	
	/**
	 * 处理区域数据
	 */
	function doSetData(xmlDoc){
		areaXmlDoc = xmlDoc;

		//获取区域名称
		cName = xmlGetAttribute(areaXmlDoc,"name");

		//获取组件信息块
		var compXmls = xmlDoc.getElementsByTagName("component");
		if (compXmls==null){
			return;
		}
		//循环处理组件
		var ii=0;
		while(ii<compXmls.length){
			var i=ii;
			ii++;
			if (compXmls[i]==null){
				continue;
			}
			var compVO = new CompValueObject(); //构建新的组件块
			
			compVO.setData(compXmls[i]); //设置组件数据
			
			compList.add(compVO); //放入序列
		}
	}
}


/**
 * 组件信息容器
 */
function CompValueObject(){
	
	var action; //动作路径
	var modelUrl; //模板路径
	var compXmlDoc; //数据块
	var aName; //组件名称
	var aPK; //组件主键
	
	this.setData = doSetData; //设置数据
	this.getModelUrl = doGetModelUrl; //获取模板路径
	this.getAction = doGetAction; //获取动作路径
	this.getName = doGetName; //获取组件名称
	this.getPK = doGetPK; //获取组件主键
	
	/**
	 * 获取组件主键
	 */
	function doGetPK(){
		return aPK;
	}
	
	/**
	 * 获取组件名称
	 */
	function doGetName(){
		return aName;
	}
	
	/**
	 * 获取模板路径
	 */
	function doGetModelUrl(){
		return modelUrl;
	}
	
	/**
	 * 获取动作路径
	 */
	function doGetAction(){
		return action;
	}
	
	/**
	 * 设置数据
	 */
	function doSetData(xmlDoc){
		
		compXmlDoc = xmlDoc;
		aName = xmlGetAttribute(compXmlDoc,"name");
		aPK = xmlGetAttribute(compXmlDoc,"pk");
		try{ 
			action = compXmlDoc.getElementsByTagName("action")[0].text;
		}catch(e){}
		try{ 
			modelUrl = compXmlDoc.getElementsByTagName("modelurl")[0].text;
		}catch(e){}
	}
}