/** ********************************* 页面键盘控制实现 Start ********************************* */

//进入页面默认键盘失效
//setKeyControl(null, true); 

/**
 * 页面初始化方法，默认每个页面body在onLoad时调用（定义在各个layout里）
 * 如需扩展，可在子页面里重写该extraInit()方法；如需定制，可在子页面里重写initTime();initKeyControl();initStyle();initFirstFocus();initRowBgColor()等方法
 * 参数：无
 * 
 * e.g. :  init()
 * 
 */
function init() {
	//initTime();
	//initKeyControl();
	//initStyle();
	//initFirstFocus();
	//initRowSpan();
	//initRowBgColor();
	initProcess();
	initMessage();
	initError();
	extraInit();
}
function initTime() {
	showTime();
}
function initKeyControl() {
	setKeyControl();
}
function initStyle() {
	generateStyle();
}
function initFirstFocus() {
	setFirstFocus();
}
function initRowSpan() {
}
function initRowBgColor() {
	generateRowBgColor();
}
function initProcess() {
	//关闭遮挡层
	hideProcess();
}
function initMessage() {
	//显示提示信息
}
//记录是否已提示信息，在newpos的 ErrorsTag里使用
var ERROR_ALERT = false;
function initError() {
	//显示出错信息
}
function extraInit() {
	//需定制的初始化操作
}

/**
 * 显示电子时钟
 * 参数：无
 *           
 * e.g. :  showTime()
 * 
 */
function showTime() {
	if (document.getElementById("jnkc")) {
		jnkc.innerText=new Date().toLocaleString();
		setInterval("jnkc.innerText=new Date().toLocaleString()", 1000);
	}
}

/**
 * 显示进度提示并屏蔽键盘操作（一般用于页面提交时）
 * 参数：boolean，是否显示遮挡层
 *           
 * e.g. :  showProcess() // 显示提示层
 *         showProcess(true) // 显示遮挡层及提示层
 * 
 */
function showProcess(_showCover) {
	//if (_showCover) {
	//	showElement(true, "coveringDIV");
	//}
    //showElement(true, "processDIV");
    
    //setKeyControl(null, true); // 页面键盘控制失效
}

/**
 * 恢复键盘操作隐藏进度提示
 * 参数：无
 *           
 * e.g. :  hideProcess() 
 * 
 */
function hideProcess() {
	//initKeyControl(); // 恢复页面键盘控制设置
	
	showElement(false, "processDIV");
    showElement(false, "coveringDIV");
}

/**
 * 配置页面键盘控制
 * 参数：String[]，控制键盘按钮类型："All"（全部），"Fx"（F1～F12）, "Enter", "exNum"（小键盘数字0～9）, "Esc", "AltF4"(Alt+F4),
 *                                   "Num"（数字0～9）, "Direction"（方向：上下左右）,"UpDown"（方向：上下）， "Other"（其他系统默认快捷键）
 *      boolean，是否让键盘失效，缺省为false，如果指定为true，则第一个参数无效
 *           
 * e.g. :  setKeyControl()  // 缺省为控制键盘上"Fx", "Enter", "Esc", "AltF4", "Other"这几种类型的按钮
 *         setKeyControl(new Array('Fx', 'Esc', ...)) // 控制键盘上"Fx", "Esc"类型的按钮
 * 
 */
var KEYCTRL_REG = null;
function setKeyControl(_reg, _ignoreKey) {
	if (_ignoreKey) {
		document.onkeydown = function() {
								 var _keycode = event.keyCode;
								 try {
								 	 event.keyCode = 0;
								 } catch(e) {}

								 event.returnValue = false;
					             if (event.altKey && (_keycode == 115)) {
					             	 //hideProcess(); // 可暂时开启Alt＋F4关闭窗口，方便调试－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
					                 event.keyCode=0;
					                 window.showModelessDialog(
					                     "about:blank",
					                     "",
					                     "dialogWidth:0px;dialogheight:0px");
						         }
							 };
	} else {
	    if (!_reg || _reg.length == 0) {
	        _reg = new Array("Fx", "Enter", "Esc", "AltF4", "Other");
	    } else {
	        _reg = _reg;
	    }

	    document.onkeydown = function(){configKeyControl(_reg)};
	    KEYCTRL_REG = _reg;
	    document.onmousedown = doMouseDown;
	    window.onhelp = new Function("return false;");
    }
}

/**
 * 扩充键盘控制按钮类型
 * 参数：String[]，扩充的控制键盘按钮类型，详见setKeyControl方法注释
 * 
 * e.g. :  attachKeyControl(new Array("Direction")) // 扩充控制方向键
 * 
 */
function attachKeyControl(_ex) {
	if (!_ex) {
		return;
	}
	
	var _reg = _ex;
	if (KEYCTRL_REG) {
		_reg = _reg.concat(KEYCTRL_REG);
	}

	if (_reg) {
		document.onkeydown = function(){configKeyControl(_reg)};
		KEYCTRL_REG = _reg;
	}
}

/**
 * 去除键盘控制按钮类型
 * 参数：String[]，去除的控制键盘按钮类型，详见setKeyControl方法注释
 * 
 * e.g. :  detachKeyControl(new Array("Direction")) // 去除控制方向键
 * 
 */
function detachKeyControl(_ex) {
	var _reg = new Array();
	if (!KEYCTRL_REG || !_ex) {
		return;
	} else {
		for (var i = 0; i < KEYCTRL_REG.length; i++) {
			var _par = KEYCTRL_REG[i];
			var _exist = false;
			for (var j = 0; j < _ex.length; j++) {
				if (_par.toLowerCase() == _ex[j].toLowerCase()) {
					_exist = true;
					break;
				}
			}
			if (!_exist) {
				_reg.push(_par);
			}
		}

		document.onkeydown = function(){configKeyControl(_reg)};
		KEYCTRL_REG = _reg;
	}
}

/**
 * 配置页面键盘控制（供setKeyControl()方法使用）
 * 参数：String[]，控制键盘按钮类型，参见setKeyControl()方法
 */
function configKeyControl(_reg) {
    var keycode = event.keyCode;
    //alert(keycode)
    
    var isAll = (_reg[0].toLowerCase() == "all");

    for (var i = 0; i < _reg.length; i++) {
    
    	//组合键
    	var _isComb = event.ctrlKey || event.altKey || event.shiftKey;
    	
    	if (_isComb) {
	        if (isAll || "altf4" == _reg[i].toLowerCase()) {
	        	// 可暂时开启Alt＋F4关闭窗口，方便调试－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
	            if ((event.altKey) && (keycode == 115)) {
	                event.returnValue = false;
	                window.showModelessDialog(
	                    "about:blank",
	                    "",
	                    "dialogWidth:0px;dialogheight:0px");
	            }
	        }
	        
	        if (isAll || "other" == _reg[i].toLowerCase()) {
	        	//屏蔽Ctrl＋N
	        	if ((event.ctrlKey) && (event.keyCode==78)) {
	                event.returnValue = false;

	        	//屏蔽Ctrl＋W
	            } else if ((event.ctrlKey) && (event.keyCode==87)) {
	                event.returnValue = false;

	            //屏蔽Ctrl＋A
	            } else if ((event.ctrlKey) && (event.keyCode==65)) {
	                event.returnValue = false;

	            //屏蔽Ctrl＋R
	            } else if ((event.ctrlKey) && (event.keyCode==82)) {
	                event.returnValue = false;
	                
	            //屏蔽Ctrl＋H
	            } else if ((event.ctrlKey) && (event.keyCode==72)) {
	                event.returnValue = false;
	            
	            //屏蔽Ctrl＋E
	            } else if ((event.ctrlKey) && (event.keyCode==69)) {
	                event.returnValue = false;
	                
	            //屏蔽Ctrl＋I
	            } else if ((event.ctrlKey) && (event.keyCode==73)) {
	                event.returnValue = false;
	                
	            //屏蔽Ctrl＋O
	            } else if ((event.ctrlKey) && (event.keyCode==79)) {
	            	event.keyCode = 0;
	                event.returnValue = false;
	                
	            //屏蔽Ctrl＋L
	            } else if ((event.ctrlKey) && (event.keyCode==76)) {
	                event.returnValue = false;
	                
	            //屏蔽Ctrl＋B
	            } else if ((event.ctrlKey) && (event.keyCode==66)) {
	                event.returnValue = false;

	            //屏蔽Alt＋←
	            } else if ((event.altKey) && (event.keyCode==37)) {
	                event.returnValue = false;

	            //屏蔽Alt＋→
	            } else if ((event.altKey) && (event.keyCode==39)) {
	                event.returnValue = false;

	            //屏蔽Shift＋F10
	            } else if ((event.shiftKey) && (event.keyCode==121)) {
	                event.returnValue = false;
	            }
	        }
	        
        } else {
	        //单个按键
	        if (isAll || "enter" == _reg[i].toLowerCase()) {
	            if (keycode == 13) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                enter();
	            }
	        }
	
	        if (isAll || "esc" == _reg[i].toLowerCase()) {
	            if (keycode == 27) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                Esc();
	            }
	        }
	    
	        if (isAll || "fx" == _reg[i].toLowerCase()) {
	            if (keycode == 112) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F1();
	            } else if (keycode == 113) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F2();
	            } else if (keycode == 114) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F3();
	            } else if (keycode == 115) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F4();
	            } else if (keycode == 116) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F5();
	            } else if (keycode == 117) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F6();
	            } else if (keycode == 118) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F7();
	            } else if (keycode == 119) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F8();
	            } else if (keycode == 120) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F9();
	            } else if (keycode == 121) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F10();
	            } else if (keycode == 122) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F11();
	            } else if (keycode == 123) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                F12();
	            }
	        }
	        
			//方向键
	        if (isAll || "direction" == _reg[i].toLowerCase()) {
	            if (keycode == 37) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                left();
	            } else if (keycode == 38) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                up();
	            } else if (keycode == 39) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                right();
	            } else if (keycode == 40) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                down();
	            }
	        }
	        
	        //方向键的上下键
	        if ("updown" == _reg[i].toLowerCase()) {
	            if (keycode == 38) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                up();
	            } else if (keycode == 40) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                down();
	            }
	        }
	        
	        //数字键
	        if (isAll || "num" == _reg[i].toLowerCase()) {
	            if (keycode == 49) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                one();
	            } else if (keycode == 50) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                two();
	            } else if (keycode == 51) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                three();
	            } else if (keycode == 52) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                four();
	            } else if (keycode == 53) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                five();
	            } else if (keycode == 54) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                six();
	            } else if (keycode == 55) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                seven();
	            } else if (keycode == 56) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                eight();
	            } else if (keycode == 57) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                nine();
	            } else if (keycode == 48) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                zero();
	            }
	        }
	        
	        //小键盘
	        if (isAll || "exnum" == _reg[i].toLowerCase()) {
	            if (keycode == 97) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                one();
	            } else if (keycode == 98) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                two();
	            } else if (keycode == 99) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                three();
	            } else if (keycode == 100) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                four();
	            } else if (keycode == 101) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                five();
	            } else if (keycode == 102) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                six();
	            } else if (keycode == 103) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                seven();
	            } else if (keycode == 104) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                eight();
	            } else if (keycode == 105) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                nine();
	            } else if (keycode == 96) {
	                event.keyCode = 0;
	                event.returnValue = false;
	                zero();
	            }
	        }
	        
	        //其它
	        if (isAll || "other" == _reg[i].toLowerCase()) {
	        	
	        }
	    }
    }
}

/**
 * 判断被点击的button或超链接的显示值，调用相应的函数（供setKeyControl()方法使用）
 * 参数：无
 */
function doMouseDown() {
    if (event.button == 1) {
    	var buttonName = null;

    	if (!event.srcElement || event.srcElement.disabled) return;

    	if (event.srcElement.tagName == "A") {
    		buttonName = event.srcElement.innerHTML;
    	} else if (event.srcElement.type == "button"){
    		if (!event.srcElement.disabled) {
    			buttonName = event.srcElement.value;
    		}
    	}
    	
    	if (!buttonName) return;

        if (buttonName.indexOf("F10") != -1) {
            F10();
        } else if (buttonName.indexOf("F11") != -1) {
            F11();
        } else if (buttonName.indexOf("F12") != -1) {
            F12();
        } else if (buttonName.indexOf("F1") != -1) {
            F1();
        } else if (buttonName.indexOf("F2") != -1) {
            F2();
        } else if (buttonName.indexOf("F3") != -1) {
            F3();
        } else if (buttonName.indexOf("F4") != -1) {
            F4();
        } else if (buttonName.indexOf("F5") != -1) {
            F5();
        } else if (buttonName.indexOf("F6") != -1) {
            F6();
        } else if (buttonName.indexOf("F7") != -1) {
            F7();
        } else if (buttonName.indexOf("F8") != -1) {
            F8();
        } else if (buttonName.indexOf("F9") != -1) {
            F9();
        }
    }

}

function AltF4() {
}

function Esc() {
	//关闭页面时不需确认，如果需要确认，则在页面处理
	//if (confirm(SHUTPAGE_INFO)) {
    	shutPage();
    //}
}

function F1() {
}
function F2() {
}
function F3() {
}
function F4() {
}
function F5() {
}
function F6() {
}
function F7() {
}
function F8() {
	switchFocus();
}
function F9() {
}
function F10() {
}
function F11() {
}
function F12() {
	clearScreen(null, true, new Array("AllHidden"));
	setFirstFocus();
}
function one() {
}
function two() {
}
function three() {
}
function four() {
}
function five() {
}
function six() {

}
function seven() {

}
function eight() {

}
function nine() {

}
function zero() {

}
function enter() {
	controlCtrlFields();
}
function left() {
}
function right() {
}

//在指定Table上开启或关闭键盘控制高亮显示行的上下方向键控制
var HIGHLIGHT_ROWIDX = 0;
var HIGHLIGHT_TABLEID = null;
function up() {
	if (HIGHLIGHT_ROWIDX > 0) {
		HIGHLIGHT_ROWIDX--;
		resetRowBgColor(HIGHLIGHT_ROWIDX+1, HIGHLIGHT_TABLEID);
		setRowBgColor(HIGHLIGHT_ROWIDX, null, HIGHLIGHT_TABLEID);
		//控制记录当前选中行
		assignLineNumber();
	}
}
function down() {
	var _target = document.getElementById(HIGHLIGHT_TABLEID);
	if (HIGHLIGHT_ROWIDX < _target.rows.length-1) {
		HIGHLIGHT_ROWIDX++;
		resetRowBgColor(HIGHLIGHT_ROWIDX-1, _target);
		setRowBgColor(HIGHLIGHT_ROWIDX, null, _target);
		//控制记录当前选中行
		assignLineNumber(_target);
	}
}
//自动获取选中的行号
function assignLineNumber(_target, _val) {
	if (!_target) _target = HIGHLIGHT_TABLEID;
	if ("string" == typeof(_target)) {
		_target = document.getElementById(_target);
	}
	
	if (_target) {
		var _value = HIGHLIGHT_ROWIDX + 1;

		if (_val || _val == '') {
			_value = _val;
		} else if (_target.rows[0].id == "layoutTR") {
			_value--;
		}
		
		setParamValue("operateId", _value);
	}
}

/**
 * 清屏：清空指定区域中所有控件的值，默认保留button、submit、reset、image、disabled这几种类型控件的value
 * 参数： String，指定form的name，缺省清空页面第一个form里的值
 *       boolean, true：需用户确认的提示信息；false：不需要用户确认
 *       String[]，需保留值的控件名数组，控件名可以是“AllReadonly”（所有只读控件），“AllHidden”（所有隐藏控件），
 *                “AllButton”（所有按钮），"AllSubmit"（所有提交按钮），"AllReset"（所有重置按钮），"AllImage"（所有图片按钮），
 *                 "AllDisabled"（所有失效的控件）
 *                 指定其中任何一个或多个类型则会保留属于这种类型的所有控件的值
 *           
 * e.g. :  clearScreen()              // 清空页面第一个Form里所有的控件值
 *         clearScreen('targetForm')   // 清空“targetForm”表单里所有的控件值
 *         clearScreen('targetForm', true, new Array('ssdw', 'ZT', ...)) // 清空“targetForm”里除name为“ssdw”和“ZT”外所有的控件值，并提示用户确认对话框
 *         clearScreen('targetForm', false, new Array('AllReadonly', 'ssdw')) // 清空“targetForm”里除所有类型为readonly和name为“ssdw”外所有的控件值，不提示确认
 *         clearScreen(null, true, new Array("AllHidden")) // 清空页面第1个form里除所有hidden控件的值，并提示用户确认对话框
 * 
 */
var CONFIRM_INFO = "请您确认是否需要清屏？";
function clearScreen(_target, _needConfirm, _exclude) {
	if (!_target) {
		if (document.forms[0]) {
			_target = document.forms[0];
		} else {
			return;
		}
	} else if ("string" == typeof(_target)) {
		_target = document.getElementById(_target);
	}
	
	if (_target) {
		if (_needConfirm && !confirm(CONFIRM_INFO)) return;
		
		var _defaultExclude = new Array("AllButton", "AllSubmit", "AllReset", "AllImage", "AllDisabled");
		if (!_exclude) {
			_exclude = _defaultExclude;
		} else {
			_exclude = _exclude.concat(_defaultExclude);
		}
		
		var _allObjs = _target.elements;
		
		Outer: for (var i = 0; i < _allObjs.length; i++) {
			var _obj = _allObjs[i];
			for (var j = 0; j < _exclude.length; j++) {
				if ("allbutton" == _exclude[j].toLowerCase() && "button" == _obj.type) {
					continue Outer;
				} else if ("allsubmit" == _exclude[j].toLowerCase() && "submit" == _obj.type) {
					continue Outer;
				} else if ("allreset" == _exclude[j].toLowerCase() && "reset" == _obj.type) {
					continue Outer;
				} else if ("allimage" == _exclude[j].toLowerCase() && "image" == _obj.type) {
					continue Outer;
				} else if ("allhidden" == _exclude[j].toLowerCase() && "hidden" == _obj.type) {
					continue Outer;
				// 因为现在的disabled效果是用readonly加样式做出来的，所以特殊处理－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
				//} else if ("alldisabled" == _exclude[j].toLowerCase() && _obj.disabled) {
					//continue Outer;
				} else if ("alldisabled" == _exclude[j].toLowerCase() && _obj.readOnly && _obj.name.indexOf("Disabled.") == 0) {
					continue Outer;
				} else if ("allreadonly" == _exclude[j].toLowerCase() && _obj.readOnly) {
					continue Outer;
				} else if (_obj.name == _exclude[j]) {
		            continue Outer;
		        }
		    }
		    clearValue(_obj);
		}
	}
    /**
    var _allInput = _target.getElementsByTagName("INPUT");
    Outer1 : for (var i = 0; i < _allInput.length; i++) {
        if (_allInput[i].type == "button")
            continue;

        if (_exclude) {
            for (var j = 0; j < _exclude.length; j++) {
                if (_exclude[j] == _allInput[i].name)
                    continue Outer1;
            }
        }
        _allInput[i].value = '';
    }

    var _allSelect = _target.getElementsByTagName("SELECT");

    Outer2 : for (var i = 0; i < _allSelect.length; i++) {
        if (_exclude) {
            for (var j = 0; j < _exclude.length; j++) {
                if (_exclude[j] == _allSelect[i].name)
                    continue Outer2;
            }
        }
        _allSelect[i].selectedIndex = 0;
    }
    */
}

/**
 * 设置页面的初始焦点
 * 参数：String，起始控件名
 *      boolean，如果未指定起始控件名，则true：初始焦点落在第一个可见并且为空值的控件上；false：初始焦点落在第一个可见控件上
 *           
 * e.g. :  setFirstFocus('TX')          // 将页面初始焦点设置在“TX”控件上
 *         setFirstFocus() 				// 自动设置初始焦点
 *         setFirstFocus(null, true) 	// 自动设置初始焦点，跳过有值的控件
 * 
 */
function setFirstFocus(_target, _valueSensitive) {
	if (_target) {
		setFocus(_target);
	} else if (document.forms[0]){
		var _allObjs = document.forms[0].elements;
		for (var i = 0; i <= _allObjs.length; i++) {
			if (i == _allObjs.length) {
				if (_valueSensitive) {
					setFirstFocus();
					return;
				} else {
					break;
				}
			}
		
            if (_valueSensitive) {
            	if (_allObjs[i].type == "select-one" && _allObjs[i].selectedIndex > 0) {
        			continue;
        		} else if (_allObjs[i].value) {
            		continue;
            	}
            }
            if (setFocus(_allObjs[i])) {
                break;
            }
		}
	}
}

/**
 * 列表与输入框之间的焦点切换
 * 参数：String[]，要切换的区域名称或id数组，默认切换对象为“dynamicTT”(列表table)和“operateId”（行号输入框）
 *
 * e.g. :  switchFocus() //页面焦点在“dynamicTT”和“operateId”两者间切换
 *         switchFocus(new Array('myTableDIV1', 'myTableDIV2', 'operateId')) //页面焦点在“myTableDIV”, “myTableDIV2”,“operateId”三者间切换
 * 
 */
var SWITCH_INDEX = -1;
function switchFocus(_targets) {
	if (!_targets || _targets.length < 2) {
		if (document.getElementById("dynamicTT") && document.getElementById("operateId") && canFocus("operateId")) {
			_targets = new Array("dynamicTT", "operateId");
		} else {
			return;
		}
	}
	if (SWITCH_INDEX == (_targets.length-1)) {
		SWITCH_INDEX = 0;
	} else {
		SWITCH_INDEX++;
	}
	
	var _target = document.getElementById(_targets[SWITCH_INDEX]);
	
	if (_target.tagName == "TABLE") {
		controlTable(true, null, _target);
	} else {
		controlTable(false, HIGHLIGHT_ROWIDX, HIGHLIGHT_TABLEID);
	}
	setFocus(_target);
}

/**
 * 在指定Table上开启或关闭键盘控制高亮显示行
 * 参数：boolean，true：开启；false：关闭
 *       int,    如果参数1为true：高亮显示的行号，缺省为HIGHLIGHT_ROWIDX；为false：无缺省值
 *       String, 目标table的名字，缺省为“dynamicTT”
 *           
 * e.g. :  controlTable(true)   // 在默认Table上开启键盘控制高亮显示行
 *         controlTable(false, "MyTable")  // 在MyTable上关闭键盘控制高亮显示行
 *         controlTable(false, 2, "MyTable")  // 在MyTable上关闭键盘控制高亮显示行,高亮显示第3行
 * 
 */
function controlTable(_oper, _rowIdx, _target) {
	if (!_target) _target = "dynamicTT";
	if ("string" == typeof(_target)) {
		_target = document.getElementById(_target);
	}
	
	if (_oper) {
		if (_rowIdx == null || _rowIdx == "undefined") {
			_rowIdx = HIGHLIGHT_ROWIDX;
		}
		if (!_rowIdx || !_target.rows[_rowIdx]) {
			_rowIdx = 0;
		}
		
		if (_target.rows[_rowIdx]) {
			HIGHLIGHT_ROWIDX = _rowIdx;
			HIGHLIGHT_TABLEID = _target.id;
			attachKeyControl(new Array("UpDown"));
			setRowBgColor(_rowIdx, null, _target);
			//记录选中行号
			assignLineNumber(_target);
		}

	} else {
		if (_rowIdx != null && _rowIdx != "undefined") {
			_rowIdx = HIGHLIGHT_ROWIDX;
		}
		//清空记录选中行号
		assignLineNumber(_target, "");
		detachKeyControl(new Array("UpDown"));
		resetRowBgColor(_rowIdx, _target);
	}
}

/**
 * 设置页面的焦点
 * 参数：String，起始控件或控件名
 * 返回值：boolean，true：落焦点成功；false：落焦点失败
 *           
 * e.g. :  setFocus('TX')          // 将页面焦点设置到“TX”控件上
 * 
 */
function setFocus(_target) {
	var _return = false;
	if ("string" == typeof(_target)) {
		_target = document.getElementById(_target);
	}
	
	if (canFocus(_target)) {
		try {
		    if (_target.type == "text" || _target.type == "password") {
		    	// 解决下一个焦点到下拉框，该文本框还是select状态问题
		    	if (!_target.onblur) {
		    		_target.onblur = function () {var _tmp = _target.value; _target.value = ""; _target.value = _tmp;}
		    	}
		    	_target.focus();
				_target.select();
			} else {
				_target.focus();
			}
			_return = true;
		} catch (e) {}
	}

	return _return;
}

/**
 * 设置需响应提交事件的控件集合(一般在body onload时调用)
 * 参数：object，存放控件名及其对应的function
 * 
 * e.g. :  setCtrlFields({
 *                        "fieldName1" : "function1()",
 *						  "fieldName2" : "function2()", 
 *					       ...
 *                        })
 * 
 */
var CTRL_FIELDS = null;
function setCtrlFields(_params) {
	if (_params) {
		CTRL_FIELDS = _params;
	}
}

function controlCtrlFields() {
	var _field = event.srcElement;

	if (_field.name && CTRL_FIELDS && CTRL_FIELDS[_field.name]) {
		eval(CTRL_FIELDS[_field.name]);
		//if (CTRL_FIELDS["formName"]) {
			//var _form = eval("document.all." + CTRL_FIELDS["formName"]);
			
			//_form.action = CTRL_FIELDS[_field.name];
			//_form.submit();
		//}
	} else {
		nextFocus(_field);
	}
}

/**
 * 将焦点移到下一个控件,可以排除某些控件（默认排除hidden，file, readOnly, disabled类型的控件）
 * 参数：String，起始控件对象或控件名
 *      String[]，需排除的控件名数组
 * 
 * e.g. :  nextFocus('TX')                               // 将页面焦点从“TX”移到下一个控件
 *         nextFocus('TX', new Array('ssdw', 'ZT', ...)) // 将页面焦点从“TX”移到下一个控件，如果下个控件名是“ssdw”和“ZT”则跳过
 * 
 */
function nextFocus(_target, _exclude) {
	var _srcObj = null;
	try {
			if (!_target.type) {
		    	_srcObj = document.getElementById(_target);
		    } else {
		    	_srcObj = _target;
		    }
		    if (!_srcObj.form) return;
	    } catch(e) {
	    	return;
	    }
	    
    var _allObjs = _srcObj.form.elements;

    for (var i = 0; i < _allObjs.length; i++) {

        if (_srcObj == _allObjs[i]) {
			var _loopCount = 0;
            Outer1 : for (var j = i + 1; j <= _allObjs.length; j++) {
                if (j == _allObjs.length) {
                	j = 0;
                	_loopCount++;
               	}
               	if (_loopCount == 2) break; // 避免死循环
                
                var _nextObj = _allObjs[j];
                
                if (_exclude) {
                    for (var k = 0; k < _exclude.length; k++) {
                        if (_exclude[k] == _nextObj.name) continue Outer1;
                    }
                }
                //如果是同一组的radio控件，则跳过
                if (_nextObj.type && _nextObj.type == "radio" && _nextObj.name == _srcObj.name) {
                	continue;
                }
                
                if (setFocus(_nextObj)) {
                    break;
                }
            }
        }
    }
}

/**
 * 判断是否指定控件是否能落焦点（默认排除hidden，file, readOnly, disabled，fileset等类型的控件）
 * 参数：  String，起始控件对象或控件名
 * 返回值：boolean，true：可以落焦点到该控件上；false：不能落焦点到该控件上
 * 
 * e.g. :  canFocus('TX')   // 如果TX控件为hidden，file, readOnly, disabled，fileset等类型则返回false
 * 
 */
function canFocus(_target) {
	if ("string" == typeof(_target)) {
		_target = document.getElementById(_target);
	}
	if (_target
	    && ((_target.tagName == "TABLE") || (_target.type && _target.type != "hidden" && _target.type != "file"))
        && !_target.readOnly
        && !_target.disabled
        && _target.style.visibility != "hidden" 
        && _target.style.display != "none") {
        return true;
    }
    return false;
}

/** ********************************* 页面键盘控制实现 End ********************************* */

/**
 * 去除字符串首尾的任何空白字符，包括空格、制表符、换页符等等
 * 参数： 无
 * 返回：格式化后的字符串
 *           
 * e.g. :  var _str = " test "; _str.trim(); // return "test"
 * 
 */
String.prototype.trim = function()
{
	return this.replace(/(^\s*)|(\s*$)/g, "");
}
/**
 * 去除字符串左边的任何空白字符，包括空格、制表符、换页符等等
 * 参数： 无
 * 返回：格式化后的字符串
 *           
 * e.g. :  var _str = " test "; _str.trimL(); // return "test "
 * 
 */
String.prototype.trimL = function()
{
	return this.replace(/(^\s*)/g, "");
}
/**
 * 去除字符串右边的任何空白字符，包括空格、制表符、换页符等等
 * 参数： 无
 * 返回：格式化后的字符串
 *           
 * e.g. :  var _str = " test "; _str.trimR(); // return " test"
 * 
 */
String.prototype.trimR = function()
{ 
	return this.replace(/(\s*$)/g, "");
}
/**
 * 去除字符串里的任何空白字符，包括空格（全角/半角）、制表符、换页符等等
 * 参数： 无
 * 返回：格式化后的字符串
 *           
 * e.g. :  var _str = " t e s t "; _str.trimBlank(); // return "test"
 * 
 */
String.prototype.trimBlank = function()
{
	return this.replace(/　|\s/g, "");
}

/**
 * 关闭指定名字的窗口(如果需要关闭多层窗口，一定要先关闭父窗口再关闭子窗口)，该方法不推荐使用！！！
 * 参数：String，控件名
 * 
 * e.g. :  shutWindow("myWin")    // 关闭名字为“myWin”的窗口
 * 
 */
function shutWindow(_winName) {
    if (_winName) {
        var _tmpWin = window.open("", _winName, "height=0;width=0");
        try {
        	if (_tmpWin.opener && (!_tmpWin.opener.closed)) {
        		_tmpWin.opener.eval("hideProcess()"); //关闭进度提示层
        	}
        } catch (e) {}
    	
        if (_webBrowser) {
			_webBrowser.ExecWB(45,1);
		} else {
			_tmpWin.opener = null;
		    _tmpWin.close();
	    }
    }
}

/**
 * 关闭当前窗口的父窗口(如果需要关闭两个窗口，一定要先关闭父窗口再关闭子窗口)
 * 参数： boolean，缺省为false；true：不关闭指定level窗口的父窗口的遮挡层；false：关闭指定level窗口的父窗口的遮挡层
 *           
 * e.g. :  shutFatherPage()  	// 关闭父窗口
 *         shutFatherPage(true) // 关闭父窗口，但不关闭父窗口的父窗口的遮挡层
 * 
 */
function shutFatherPage(_showProcess) {
	shutPage(1, _showProcess);
}

/**
 * 关闭指定窗口(如果需要关闭多层窗口，一定要先关闭父窗口再关闭子窗口)
 * 参数： int，窗口层次（缺省为0；0，当前窗口；1，当前窗口的父窗口；2，...）
 *        boolean，缺省为false；true：不关闭指定level窗口的父窗口的遮挡层；false：关闭指定level窗口的父窗口的遮挡层
 * 
 * e.g. :  shutPage() // 关闭当前窗口
 *         shutPage(2) // 关闭父窗口的父窗口
 *         shutPage(0, true) // 关闭本窗口，但不关闭父窗口的遮挡层
 * 
 */
var SHUTPAGE_INFO = "是否退出？";
function shutPage(_level, _showProcess) {
	if (!_level) _level = 0;
	
	var _win = window;
	for (var i = 0; i <= _level; i++) {
	    try {
    		if ((i == _level) && (!_win.closed)) {
    			var _webBrowser = _win.document.getElementById("WebBrowser");
    			if (!_showProcess) {
    				exePageScript("hideProcess()", i+1); //关闭进度提示层
    			}
    			if (_webBrowser) {
    				_webBrowser.ExecWB(45,1);
    			} else {
    				alert("找不到WebBrowser对象，请检查！");
    				//旧的实现方式，不推荐使用
	    			//_win.opener = null;
	    		    //_win.close();
    		    }
    		} else if (_win.opener) {
    			_win = _win.opener;
    		} else {
    		    break;
    		}
		} catch (e) {
    		break;
    	}
    }
}

/**
 * 打开默认的提示框
 * 参数： String，显示信息
 *       String，默认值
 * 返回：String or int, 用户输入的值
 *           
 * e.g. :  showPrompt()
 *         showPrompt("请输入您的员工编号：")
 *		   showPrompt("请输入需打印标签的份数：", 1)
 * 
 */
function showPrompt(_msg, _defValue) {
    return window.prompt(_msg, _defValue);
}

/**
 * 打开默认的新窗口
 * 参数： String，url
 *       String，新窗口名字
 * 返回：Object, 新窗口对象
 *           
 * e.g. :  showPage("http://localhost:9080/4GPOS/welcome.do")
 *		   showPage("http://localhost:9080/4GPOS/welcome.do", "newWin")
 * 
 */
function showPage(_url, _winName) {
	//if (!_url) {
		showProcess(true); //开启进度提示层
	//}
	if (!_winName) _winName = "";
    return window.open(_url, _winName, "");
}

/**
 * 提交页面表单并打开默认的全屏窗口显示结果
 * 参数： String，提交的url
 *       Object，Form对象或Form的名字
 *       String, 新窗口名字
 * 返回：Object, 新窗口对象
 *           
 * e.g. :  submitPage("http://localhost:9080/4GPOS/welcome.do", "LoginForm")
 *		   submitPage("http://localhost:9080/4GPOS/welcome.do", "LoginForm", "newWin")
 * 
 */
function submitPage(_url, _form, _winName) {
	if ("string" == typeof(_form)) {
		_form = document.getElementById(_form);
	}
	if (!_winName) _winName = _form.name + "Win";
	var _win = showPage("", _winName);
	
	var _tmpTarget = _form.target;
	var _tmpAction = _form.action;
	
	_form.target = _winName;
	_form.action = _url;
	_form.submit();
	
	_form.target = _tmpTarget;
	_form.action = _tmpAction;
	
	return _win;
}

/**
 * 打开默认的ModalDialog窗口
 * 参数： String，指定url
 *       String，新窗口名字
 *       int,    窗口宽度
 *       int，   窗口长度
 * 返回：Object, 新窗口对象
 *           
 * e.g. :  showDialog("http://localhost:9080/4GPOS/welcome.do")
 *         showDialog("http://localhost:9080/4GPOS/welcome.do", null, 100, 200)
 * 
 */
//function showDialog(_url, _args, _width, _height) {
function showDialog(_url, _winName, _width, _height) {
	//if (!_url) {
		showProcess(true); //开启进度提示层
	//}
	if (!_winName) _winName = "Dialog";
	//if (!_args) _args = "";
	//if (!_extFeature) _extFeature = "dialogHeight:500px;dialogWidth:507px;"

	if (!_width && !parseInt(_width)) _width = 500;
    if (!_height && !parseInt(_height)) _height = 590;
    var _left = (screen.availWidth-_width)/2;
    var _top = (screen.availHeight-_height)/2;

	var _newWin = window.open(
		        _url,
		        _winName,
		        "height="+_height+",width="+_width+",left="+_left+",top="+_top+",fullscreen=no,menubar=no,resizable=no,titlebar=no,toolbar=no,location=no,scrollbars=yes,status=no");
    //_newWin.resizeTo(_width,_height);
    //_newWin.moveTo(_left, _top);
    
	//window.showModalDialog(_url, _args, "center:yes;scroll:no;status:no;help:no;dialogHeight:"+_height+"px;dialogWidth:"+_width+"px");
    
    return _newWin;
}

/**
 * 提交页面表单到打开默认的Dialog窗口显示结果
 * 参数： String，提交的url
 *       Object，Form对象或Form的名字
 *       String, 新窗口名字
 *       int,    窗口宽度
 *       int，   窗口长度
 * 返回：Object, 新窗口对象
 *           
 * e.g. :  submitDialog("http://localhost:9080/4GPOS/welcome.do", "LoginForm")
 *		   submitDialog("http://localhost:9080/4GPOS/welcome.do", "LoginForm", "newWin")
 * 
 */
function submitDialog(_url, _form, _winName, _width, _height) {
	if ("string" == typeof(_form)) {
		_form = document.getElementById(_form);
	}
	if (!_winName) _winName = "Dialog";

	var _tmpTarget = _form.target;
	var _tmpAction = _form.action;

	var _win = showDialog("", _winName, _width, _height);
	_form.target = _winName;
	_form.action = _url;
	_form.submit();
	
    _form.target = _tmpTarget;
	_form.action = _tmpAction;

	return _win;
}

/**
 * 打开IE的Modal Dialog窗口
 * 参数： String，指定url
 *       String，窗口名
 *       int,    窗口宽度
 *       int，   窗口长度
 * 返回：String, Returns the value of the returnValue property as set by the window of the document specified in sURL
 *           
 * e.g. :  showIEModalDialog("http://localhost:9080/4GPOS/welcome.do")
 *         showIEModalDialog("http://localhost:9080/4GPOS/welcome.do", "", 100, 200)
 * 
 */
function showIEModalDialog(_url, _args, _width, _height) {
	if (!_args) _args = "";
	//return window.showModalDialog(_url, _args, "center:yes;scroll:no;status:no;help:no;dialogHeight:"+_height+"px;dialogWidth:"+_width+"px");
	if (!_width && !parseInt(_width)) _width = 500;
    if (!_height && !parseInt(_height)) _height = 590;
    var _left = (screen.availWidth-_width)/2;
    var _top = (screen.availHeight-_height)/2;

	return window.open(
		        _url,
		        _args,
		        "height="+_height+",width="+_width+",left="+_left+",top="+_top+",fullscreen=no,menubar=no,resizable=no,titlebar=no,toolbar=no,location=no,scrollbars=yes,status=no");
}

/**
 * 提交页面表单到付款窗口
 * 参数： String，提交的url
 *
 * 返回：Object, 新窗口对象
 *           
 * e.g. :  openPayment("http://localhost:9080/4GPOS/Payment.do")
 * 
 */
function openPayment(_url) {
	return submitPage(_url, document.forms[0], "Payment");
}

/**
 * 提交页面表单到付款窗口
 * 参数： String，提交的url
 *
 * 返回：Object, 新窗口对象
 *           
 * e.g. :  openPrint("http://localhost:9080/4GPOS/Print.do")
 * 
 */
function openPrint(_url) {
	return submitDialog(_url, document.forms[0], "PrintResult", 500, 260);
}

/**
 * 提交页面表单到主任授权窗口
 * 参数： String，提交的url
 *
 * 返回：Object, 新窗口对象
 *           
 * e.g. :  openAccredit("http://localhost:9080/4GPOS/Accredit.do")
 * 
 */
function openAccredit(_url) {
	return submitDialog(_url, document.forms[0], "Accredit", 500, 286);
}

/**
 * 当前窗口提交表单
 *
 * 参数：String or Object， 表单名字或对象，缺省为页面第一个表单
 *       String， 提交的URL
 *           
 * e.g. :  submitForm() // 提交页面第一个表单
 *         submitForm("loginForm") // 提交loginForm表单
 *         submitForm(null, "/loging.do?test=1") // 提交页面第一个表单到指定的URL
 * 
 */
function submitForm(_form, _url, _ctrl) {
	if (!_form) {
		if (document.forms[0]) {
			_form = document.forms[0];
		} else {
			return;
		}
	} else if ("string" == typeof(_form)) {
		_form = document.getElementById(_form);
	}
	
	var _tmpAction = _form.action;
	if (_url) {
		_form.action = _url;
	}
	
	if (_form && _form.action) {
		showProcess(true); //开启进度提示层
		_form.submit();
		_form.action = _tmpAction;
	}
}

/**
 * 提交到下载的Servlet
 *
 * 参数：String， 提交的URL
 *      String or Object， 表单名字或对象，缺省为页面第一个表单
 *       
 *           
 * e.g. :  download() // 提交页面第一个表单
 *         download("loginForm") // 提交loginForm表单
 *         download(null, "/loging.do?test=1") // 提交页面第一个表单到指定的Servlet
 * 
 */
function download(_url, _form) {
	if (!_form) {
		if (document.forms[0]) {
			_form = document.forms[0];
		} else {
			return;
		}
	} else if ("string" == typeof(_form)) {
		_form = document.getElementById(_form);
	}
	
	var _tmpAction = _form.action;
	if (_url) {
		_form.action = _url;
	}
	
	if (_form && _form.action) {
		_form.submit();
		_form.action = _tmpAction;
	}
}

/**
 * 设置页面控件值
 * 参数：String，控件名
 *      String，值
 * 
 * e.g. :  setParamValue('TX', "test")    // 将控件“TX”的值赋成“test”
 * 
 */
function setParamValue(parameter, value) {
    if (document.getElementById(parameter)) {
        document.getElementById(parameter).value = value;
    }
}

/**
 * 设置父窗口指定元素的显示值
 * 参数：object，存放页面元素名（或id）及其对应的value，可以是父窗口的Input，也可以是TD等元素
 * 
 * e.g. :  setFatherPageValue({
 *                       		"targetFieldName1" : "value1",
 *						 	 	"targetTD'sID2"    : "value2", 
 *					      		...
 *                       	  })
 * 
 */
function setFatherPageValue(_params) {
	setPageValue(_params, 1);
}

/**
 * 设置指定窗口指定元素的显示值
 * 参数：object，存放页面元素名（或id）及其对应的value，可以是指定窗口的Input，也可以是DIV、TD等元素
 *      int，窗口层次（缺省为0；0，当前窗口；1，当前窗口的父窗口；2，...）
 * 
 * e.g. :  setPageValue({
 *                        "targetFieldName1" : "value1",
 *						  "targetTD'sID2"    : "value2", 
 *					       ...
 *                        }, 2) // 在父窗口的父窗口回写显示值
 * 
 */
function setPageValue(_params, _level) {
	if (_params) {
	    if (!_level) _level = 0;
		
		var _win = window;
		var _feild = null;
		for (var i = 0; i <= _level; i++) {
		    try {
	    		if ((i == _level) && (!_win.closed)) {
	    		    for (var _feildName in _params) {
	        			_feild = _win.document.getElementById(_feildName);
	        
	        			if (_feild) {
	        			    if (_feild.tagName == "INPUT" || _feild.tagName == "SELECT") {
	        				    _feild.value = _params[_feildName];
	        				} else {
	        				    _feild.innerHTML = _params[_feildName];
	        				}
	        			}
			        }
	    		} else if (_win.opener) {
	    			_win = _win.opener;
	    		} else {
	    		    break;
	    		}
			} catch (e) {
	    		break;
	    	}
    	}
    }
}

/**
 * 执行父窗口的脚本(如果需要关闭父窗口，一定要先执行改方法再关闭父窗口)
 * 参数：String，需执行的脚本代码
 * 
 * e.g. :  exeFatherPageScript('test()') // 在父窗口执行脚本“test()”
 * 
 */
function exeFatherPageScript(_script) {
    exePageScript(_script, 1);
}

/**
 * 执行指定窗口的脚本(如果需要关闭某级窗口，一定要先执行改方法再关闭窗口)
 * 参数：String，需执行的脚本代码
 *      int，窗口层次（缺省为0；0，当前窗口；1，当前窗口的父窗口；2，...）
 * 
 * e.g. :  exePageScript('test()') // 在当前窗口执行脚本“test()”
 *         exePageScript('test()', 2) // 在父窗口的父窗口执行脚本“test()”
 * 
 */
function exePageScript(_script, _level) {
    if (!_level) _level = 0;
	
	var _win = window;
	for (var i = 0; i <= _level; i++) {
	    try {
    		if ((i == _level) && (!_win.closed)) {
    		    _win.eval(_script);
    		} else if (_win.opener) {
    			_win = _win.opener;
    		} else {
    		    break;
    		}
		} catch (e) {
    		break;
    	}
    }
}

/**
 * 设置只能同时有一组控件有值(一般在body onload时调用)
 * 
 * 参数1～n： 每一组控件对象名称，如果有多个就使用数组
 *        
 *           
 *  e.g. :  setConditions(new Array("aa", "ab"), "ba", new Array("ca", "cb"));
 *          
 */
function setConditions() {
    var _args = arguments;
	
	if (_args && _args.length > 1) {
	    var _objs = new Array();
	    for (var i = 0; i < _args.length; i++) {
	        _objs = _objs.concat(_args[i]);
	    }
	    
		for (var i = 0; i < _objs.length; i++) {
			var _obj = document.getElementById(_objs[i]);

			if (_obj) {
				if (_obj.type == "select-one") {
					_obj.onchange = function () {controlConditions(_args)};
				} else {
					_obj.onkeyup = function () {controlConditions(_args)};
				}
		    }
		}
	}
}

/**
 * 执行同时有一组控件有值
 * 
 * 参数1～n： 每一组控件对象名称，如果有多个就使用数组
 *        
 *           
 *  e.g. :  controlConditions(new Array("aa", "ab"), "ba", new Array("ca", "cb"));
 *          
 */
function controlConditions(_args) {
    var _src = event.srcElement;

    if (_src && _src.value && _src.value.length != 0) {
        var _directClear = false;
        for (var i = 0; i < _args.length; i++) {
            if (_directClear){
                clearValue(_args[i]);
			}

			if (_args[i] instanceof Array) {
			    for (var j = 0; j < _args[i].length; j++) {
			        if (_src.name ==  _args[i][j]) {
			            _directClear = true;
			        }
			    }
			} else if (_src.name == _args[i]) {
                _directClear = true;
			}
			if (!_directClear){
                clearValue(_args[i]);
			}
		}
    }
}

/**
 * 清空指定控件的值
 * 
 * 参数： 控件的名称或者空间对象
 *        
 *           
 *  e.g. :  clearValue("TX");  // 清空TX控件的值
 *          clearValue(new Array("TX", "TT"));  // 清空TX控件和TT控件的值
 *          
 */
function clearValue(_objs) {
    if (_objs) {
        var _obj = null;
        var _loopCnt = 1;
        
        if (_objs instanceof Array) _loopCnt = _objs.length;

        for (var i = 0; i < _loopCnt; i++) {
            _loopCnt == 1 ? _obj = _objs : _obj = _objs[i];
            
            if ("string" == typeof(_obj)) {
        		_obj = document.getElementById(_obj);
        	}
        	if (_obj.type == "select-one") {
            	_obj.selectedIndex = 0;
            } else {
            	_obj.value = '';
            }
        }
    }
}

/**
 * 比较两个日期大小，如果dtStart > dtEnd，返回“-1”；tStart = dtEnd，返回“0”；tStart < dtEnd，返回“1”
 * 参数：String，开始日期字符串
 *      String，结束日期字符串
 * 
 * e.g. :  compareDateValue('2006-05-05', "2006-06-06")    // 返回“1”
 *         compareDateValue('2006/07/07', "2006/06/06")    // 返回“-1”
 * 
 */
function compareDateValue(dtStart, dtEnd) {
    var temp, s;
    dtStart = formatDate(dtStart);
    dtEnd = formatDate(dtEnd);

    temp = new String(dtStart);

    s = new String("");
    for (var i = 0; i <= temp.length - 1; i++) {
        if (temp.charAt(i) == "-" || temp.charAt(i) == "/" || temp.charAt(i) == ".")
            s = s + "/";
        else {

            s = s + temp.charAt(i);
        }
    }
    dtOne = new Date(s);

    temp = new String(dtEnd);
    s = new String("");
    for (var i = 0; i <= temp.length - 1; i++) {
        if (temp.charAt(i) == "-" || temp.charAt(i) == "/" || temp.charAt(i) == ".")
            s = s + "/";
        else {
            s = s + temp.charAt(i);
        }
    }
    dtTwo = new Date(s);

    if (dtOne.valueOf() > dtTwo.valueOf()) {
        return -1;
    } else if (dtOne.valueOf() < dtTwo.valueOf()) {
        return 1;
    }

    return 0;
}

/**
 * 格式化日期
 * 参数：String，8位长度数字型或字符串型
 * 
 * e.g. :  formatDate('20060505')    // 返回“2006-05-05”
 * 
 */
function formatDate(dtValue) {
    if (dtValue.length != 8) {
        return dtValue;
    }
    var temp = new String(dtValue);
    temp =
        dtValue.substring(0, 4)
            + "-"
            + dtValue.substring(4, 6)
            + "-"
            + dtValue.substring(6, 8);
    return temp;
}

/**
 * 设置下拉框的选项
 * 参数：String or Object，下拉框的名称或下拉框对象
 *      String[] 下拉选项集合，存放所有下拉选项的value值
 *      String[] 下拉选项集合，存放所有下拉选项的text值，要和前一个数组一一对应
 *      String   下拉框选中的值
 *           
 * e.g. :  setOptions("mySel", new Array("value1","value2", ...))
 *
 *         setOptions("mySel", new Array("value1","value2", ...),
 *						       new Array("text1" , "text2", ...))
 *
 *         setOptions("mySel", new Array("value1","value2", ...),
 *						       new Array("text1" , "text2", ...),
 *                             "value2")
 *
 *         setOptions("mySel", new Array("value1","value2", ...),
 *						       null,
 *                             "value2")
 *
 */
function setOptions(_select, _values, _texts, _selValue) {
	if ("string" == typeof(_select)) {
	    _select = document.getElementById(_select);
	}
	
	_select.options.length = 0;
	
	if (_values) {
	    if (!_texts) {_texts = _values};
	    
	    for (var i = 0; i < _values.length; i++) {
	        _select.options[i] = new Option(_texts[i], _values[i]);
	    }
	}
	
	if (_selValue) {
	    _select.value = _selValue;
	}
}

/**
 * 指定行是否显示
 * 
 * 参数： boolean， true：显示； false：不显示
 *        String， 目标tr的名字或tr对象
 *           
 *   e.g. :  showRow(true, "myTR") // 显示"myTR"
 *           showRow(false, "layoutTR") // 隐藏"layoutTR"
 */
function showRow(_flag, _row) {
    showElement(_flag, _row);
}

/**
 * 自动显示到指定table的指定row（如果有滚动条则自动scroll到row所在位置）
 * 
 * 参数： int row的序号（从0开始）
 *       String 指定table的id（缺省为“dynamicTT”）
 *           
 *   e.g. :  scrollToRow(5) // 滚动到“dynamicTT”的第5行
 *           scrollToRow(3, "MyTable") // 滚动到“MyTable”的第3行
 */
function scrollToRow(_rowIdx, _target) {
    if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (_target) {
    	if (!_rowIdx) _rowIdx = 0;
    	_target.rows[_rowIdx].scrollIntoView(false);
    }
}

/**
 * 显示指定元素
 * 
 * 参数： boolean， true：显示； false：不显示
 *        String， 目标页面元素的名字或对象
 *        boolean, 是否忽略display属性，缺省为忽略
 *           
 *   e.g. :  showElement(true, "myDIV") // 显示"myDIV"
 *           showElement(false, "myDIV") // 隐藏"myDIV"
 *           showElement(false, "myDIV", true) // 使用style.visibility方式隐藏"myDIV"
 */
function showElement(_flag, _ele, _ignoreDisplay) {
    if (_ele && "string" == typeof(_ele)) {
        _ele = document.getElementById(_ele);
    }
    
    if (_ele) {
	    if (_flag) {
	    	if (!_ignoreDisplay) {
	        	_ele.style.display = "block";
	        }
	        _ele.style.visibility = "visible";
	    } else {
	    	_ele.style.visibility = "hidden";
	    	
	    	if (!_ignoreDisplay) {
	        	_ele.style.display = "none";
	        }
	    }
	}
}

/**
 * 在指定的layout Row所在的table中动态增加新的行（table中必须有一个layout行来指定样式）
 * 
 * 参数： String，目标layout行的名字，缺省为“layoutTR”
 *
 * 返回：  Object，新tr对象
 *        
 *   e.g. :  copyRow(); // 直接插入一个复制的新行
 *           copyRow("layoutTR") // 插入新行到指定的table
 */
var isShowLayoutRow = true;
function copyRow(_layoutRow) {

    if (!_layoutRow) _layoutRow = "layoutTR";
    if ("string" == typeof(_layoutRow)) {
        _layoutRow = document.getElementById(_layoutRow);
    }
    
    if (_layoutRow) {
        var _table = _layoutRow.parentElement.parentElement;
        var _newTR = _layoutRow.cloneNode(true);
        
        // 插入新行
        _table.rows[_table.rows.length-1].insertAdjacentElement("afterEnd", _newTR);
        
        _newTR.id = "";
        showRow(true, _newTR);
        _newTR.scrollIntoView(false);
        
        if (isShowLayoutRow) {
            showRow(false, _layoutRow);
            isShowLayoutRow = false;
        }
        
        return _newTR;
    } else {
        return null;
    }
}

/**
 * 在指定table中动态改变指定行里控件及显示的值
 * 
 * 参数： String[]，按td顺序排列的值
 *       String[], 所有hidden控件的值
 *       int，    设置需改变值的行的序号，从0开始，缺省为最后一行
 *       String， 目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  setRowValue(new Array('肥皂', '37.00', '12')); // 为“dynamicTT”的最后一行设置value
 *           setRowValue(null, new Array('aa', 'bb'), 3) // 为“dynamicTT”的第3行的hidden控件设置value
 *           setRowValue(new Array('肥皂', '37.00'), new Array('aa', 'bb'), 3) // 为“dynamicTT”的第3行所有控件设置value
 *           setRowValue(new Array('肥皂', '37.00'), new Array('aa', 'bb'), 5, "myTable") // 为“myTable”的第5行所有控件设置value
 */
function setRowValue(_newValue, _hidValue, _rowIdx, _target) {
    if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (!_rowIdx) _rowIdx = _target.rows.length-1;
    
    var _targetTR = _target.rows[_rowIdx];
    
    if (_newValue && _newValue.length >= _targetTR.cells.length) {
        for (var i = 0; i < _targetTR.cells.length; i++) {
            var _cell = _targetTR.cells[i];
            var _texts = _cell.getElementsByTagName("INPUT");

            if (_texts.length) {
                changeObjName(_texts[0], (_targetTR.rowIndex-1));
                
                _texts[0].value = _newValue[i];
            } else {
                _cell.innerHTML = _newValue[i];
            }
        }
    }
    
    if (_hidValue && _hidValue.length) {
        var _idx = 0;
        var _ipts = _targetTR.getElementsByTagName("INPUT");
        for (var i = 0; i < _ipts.length; i++) {
            if (_ipts[i].type == "hidden") {
                changeObjName(_ipts[i], (_targetTR.rowIndex-1));
                _ipts[i].value = _hidValue[_idx];
                _idx++;
            }
        }
    }
}

/**
 * 统一改变某个控件的名字成“list[n].item”的格式
 * 
 * 参数： _obj，需改名的控件对象
 *        int，行号
 *           
 */
function changeObjName(_obj, _seq) {
    var _name = _obj.name;
    if (_obj && _obj.name.indexOf("layoutTR.") == 0) {
        _name = _obj.name.replace("layoutTR.", "");
    }

    _name = _name.replace(/(\[\d\])/g, "[" + _seq + "]");
    _obj.name = _name;
    _obj.id = _name;

}

/**
 * 在指定table中动态改变指定单元格的显示值
 * 
 * 参数： String，需设置的置（html格式）
 *       int, 行序号（从0开始）
 *       int，列序号（从0开始）
 *       String， 目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  setCellValue("<font color=green>√</font>", 1, 6); // 设置“dynamicTT”的第1行的第6列设置value为“绿色的√”
 *           setCellValue("48",5, 5, "myTable") // 设置“myTable”的第5行的第5列设置value为“48”
 */
function setCellValue(_value, _rowIdx, _cellIdx, _target) {
    if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (_target && _target.rows[_rowIdx] && _target.rows[_rowIdx].cells[_cellIdx]) {
        _target.rows[_rowIdx].cells[_cellIdx].innerHTML = _value;
    }
}

/**
 * 在指定table中动态删除指定的行
 * 
 * 参数： int，  删除行的序号，从0开始，缺省为第一行
 *        String， 目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  delRow(); // 直接删除“dynamicTT”table的第1行
 *           delRow(3) //删除“dynamicTT”table的第3行
 *           delRow(5, "myTable") // 删除“myTable”table的第5行
 */
function delRow(_rowIdx, _target) {
    if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (!_rowIdx) _rowIdx = 0;
    
    if (_target.rows[_rowIdx]) {
        _target.deleteRow(_rowIdx);
    }
}

/**
 * 在指定table中删掉除“layoutTR”外的所有行
 * 
 * 参数： String， 目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  delAllRows(); // 删掉“dynamicTT”表除“layoutTR”外的所有行
 *           delAllRows("myTable") //删掉“myTable”的除“layoutTR”外的所有行
 */
function delAllRows(_target) {
    if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }

    if (_target.rows.length) {
	    if (_target.rows[_target.rows.length-1].id != "layoutTR") {
	        delRow((_target.rows.length-1), _target);
	    } else if (_target.rows.length != 1){
	    	delRow((_target.rows.length-2), _target);
	    } else {
	    	return;
	    }
    	delAllRows(_target);
    }
}

/**
 * 在指定table中设置指定行的背景显示颜色
 * 
 * 参数： int，   设置颜色行的序号，从0开始，缺省为0
 *        String，Html颜色代码，缺省为“#7CCBFF”
 *        String，目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  setRowBgColor(); // 设置“dynamicTT”table的第1行背景显示为默认颜色
 *           setRowBgColor(3) // 设置“dynamicTT”table的第3行背景显示为默认颜色
 *           setRowBgColor(5,"blue", "myTable") // 设置“myTable”table的第5行背景显示为蓝色
 */
function setRowBgColor(_rowIdx, _color, _target) {
    if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (!_rowIdx) _rowIdx = 0;
    
    //忽略样式行
    if (_target.rows[_rowIdx].id == "layoutTR") {
    	if (_rowIdx == HIGHLIGHT_ROWIDX && _target.rows.length > 1) {
    		_rowIdx++;
	    	HIGHLIGHT_ROWIDX++;
    	}
    }
    var _row = _target.rows[_rowIdx];
    
    if (!_color) _color = "#7CCBFF";
    
    //设置该行的原始颜色到其originalBgColor属性上
    if (!_row.originalBgColor) {
	    var _originalBgColor = _row.bgColor ? _row.bgColor : _row.style.backgroundColor;
	    
	    if (!_originalBgColor) {
	    	_originalBgColor = _row.cells[0].bgColor ? _row.cells[0].bgColor : _row.cells[0].style.backgroundColor;
	    }
	    _row.originalBgColor = _originalBgColor;
    }
    
    //设置所有TD的背景色为空
    for (var i = 0; i < _row.cells.length; i++) {
	    var _cell = _row.cells[i];
	    if (_cell.bgColor || _cell.style.backgroundColor) {
	        _cell.bgColor = "";
	        _cell.style.backgroundColor = "";
	    }
	}
    _row.style.backgroundColor = _color;
	_row.scrollIntoView(false);
	
	//如果触发onclick事件的是一个可见的控件，则不执行下面的方法（不自动设置焦点）
	if (event) {
		var _srcObj = event.srcElement;
		if (event.type == "click" && _srcObj) {
			if (_srcObj.type == "text" || _srcObj.type == "select-one" || _srcObj.type == "checkbox" || _srcObj.type == "button") {
				return;
			}
		}
	}
	
	//如果该行有控件，则把焦点落到第一个上面
	var _objs = _row.getElementsByTagName("INPUT");
	for (var i = 0; i < _objs.length; i++) {
        if (setFocus(_objs[i])) {
        	break;
        }
    }
}

/**
 * 在指定table中重置指定行的背景显示颜色
 * 
 * 参数： int，重置颜色行的序号，从0开始，缺省为0；如果为null或者undefined则重置所有行
 *        String，目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  resetRowBgColor();               // 重置“dynamicTT”table的第1行背景显示为其初始颜色
 *           resetRowBgColor(5, "myTable")    // 重置“myTable”table的第5行背景显示为其初始颜色
 *           resetRowBgColor(null, "myTable") // 重置“myTable”table的所有行背景显示为其初始颜色
 */
function resetRowBgColor(_rowIdx, _target) {
    if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    var _resetAll = false;
    if (_rowIdx == null || _rowIdx == "undefined") _resetAll = true;
    if (!_rowIdx) _rowIdx = 0;

    var _row = _target.rows[_rowIdx];
    
    if (!_row) {
    	return;
    }

    if (_row.originalBgColor) {
	    _row.style.backgroundColor = _row.originalBgColor;
	}

    if (_resetAll) {
	    for (var i = 0; i < _target.rows.length; i++) {
	    	_row = _target.rows[i];
			if (_row.originalBgColor) {
		    	_row.style.backgroundColor = _row.originalBgColor;
		    }
	    }
	}
}

/**
 * 在指定table中设置指定行的文字显示颜色
 * 
 * 参数： int，设置颜色行的序号，从0开始，缺省为0
 *        String，Html颜色代码，缺省为“red”
 *        String，目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  setRowColor(); // 设置“dynamicTT”table的第1行文字显示为红色
 *           setRowColor(3) // 设置“dynamicTT”table的第3行文字显示为红色
 *           setRowColor(5,"blue", "myTable") // 设置“myTable”table的第5行文字显示为蓝色
 */
function setRowColor(_rowIdx, _color, _target) {
    if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (!_rowIdx) _rowIdx = 0;
    
    if (!_color) _color = "red";
    
    _target.rows[_rowIdx].style.color = _color;
    
    var _texts = _target.rows[_rowIdx].getElementsByTagName("INPUT");
    
    if (_texts && _texts.length) {
	    for (var i = 0; i < _texts.length; i++) {
	        _texts[i].style.color = _color;
	    }
	}
}

/**
 * 设置指定控件的输入法模式为中文输入(一般在body onload时调用)
 * 
 * 参数： String or Object or Array，目标控件名称或对象集合
 *           
 * e.g. :  setChineseIME('aaa'); // 设置“aaa”控件控制输入法模式为中文输入
 *         setChineseIME(new Array('aaa', 'bbb')) // 设置“aaa”和“bbb”控件控制输入法模式为中文输入
 */
function setChineseIME(_objs) {
    if (_objs) {
    	if (_objs instanceof Array) {
    		for (var i = 0; i < _objs.length; i++) {
		        setImeMode(_objs[i], 'active');
		    }
    	} else {
    		setImeMode(_objs, 'active');
    	}
    }
}

/**
 * 设置指定控件的输入法模式
 * 
 * 参数： String or Object，目标控件名称或对象
 *        String，“active”：开启中文输入；'inactive'：关闭中文输入（缺省为取消控制输入法模式）
 *           
 * e.g. :  setImeMode('abc', null); // 设置“abc”控件取消控制输入法模式
 *         setImeMode('abc', 'active') // 设置“abc”控件控制输入法模式为中文输入
 *         setImeMode('abc', 'inactive') // 设置“abc”控件控制输入法模式为关闭中文输入
 */
function setImeMode(_target, _mode) {
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    if (_target && (_target.type == "select-one" || _target.type == "text")) {
    	if (_mode) {
    		_target.style.imeMode = _mode;
    	} else {
    		_target.style.imeMode = "auto";
    	}
    }
}

/**
 * 设置控件的样式
 * 
 * 参数：String or Object，目标控件名称或对象
 *       boolean, 是否disable
 *       boolean，是否readOnly，如果上个参数为true，则该参数无效
 *       String， 指定样式名（缺省则指定系统默认样式）
 *           
 * e.g. :  setStyle("TT", true); // 将“TT”控件设置成disabled
 *         setStyle("TT", false); // 将“TT”控件设置成正常
 *         setStyle("TT", false, true); // 将“TT”控件设置成readonly
 *         setStyle("TT", false, true, "class1"); // 将“TT”控件设置成readonly并指定样式为“class1”
 */
function setStyle(_target, _disabled, _readOnly, _class) {
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
	var _imeMode = null;

    if (_target) {
    	if (_target.type == "select-one") {
	    	if (_disabled) {
	    		_target.disabled = true;
	    		_target.className = "dselect";
	    	} else if (_readOnly) {
	    	    _target.disabled = false;
				var _idx = _target.selectedIndex;
				_target.onchange = function () {this.selectedIndex = _idx;}; // 不能改变值
				_target.onfocus = function () {nextFocus(this)};  // 不获得焦点
				_target.readOnly = true;
				_target.className = "dselect";
	    	} else {
	    		if (_target.readOnly) {
		    	    _target.onchange = ""; // 能改变值
					_target.onfocus = "";  // 能获得焦点
				}
	    	    _target.className = "";
	    		_target.disabled = false;
	    		_target.readOnly = false;
	    	}
	    	
	    	//下拉框统一关闭中文输入(下拉框不支持该方式)
	    	//_imeMode = "inactive";
	    	
		} else if (_target.type == "text" || _target.type == "password"){
			//临时保存控件的输入法模式
		    _imeMode = _target.style.imeMode;
		    
			var _disTarget = document.getElementById("Disabled." + _target.name);
			var _name = null;
            if (_disTarget && _disTarget.name) {
                _name = _disTarget.name.replace("Disabled.", "");
                _disTarget.name = _name;
                _disTarget.id = _name;
                _target = _disTarget;
            } else if (_target.name.indexOf("Disabled.") == 0) {
		    	_name = _target.name.replace("Disabled.", "");
		    	_target.name = _name;
            	_target.id = _name;
		    }
            
			if (_disabled) {
			    _target.disabled = false;
			    _target.readOnly = true;
	    		_target.name = "Disabled." + _target.name;// 加上前缀，不会被struts接收
    			_target.className = "dtext";
	    	} else if (_readOnly) {
	    	    _target.disabled = false;
	    	    _target.readOnly = true;
	    		_target.className = "dtext";
	    	} else {
	    		_target.disabled = false;
	    		_target.readOnly = false;
	    		_target.className = "ntext";
	    	}
		}
		
    	if (_class) {
    		_target.className = _class;
    	}
    	
		//恢复控件的输入法模式
    	if (_imeMode) {
    		setImeMode(_target, _imeMode);
    	} else {
    		//默认
    		setImeMode(_target, "inactive");
    	}
    }
}

/**
 * 设置页面指定区域的所有控件设置为默认样式(如果使用Struts标签，则readonly类型的下拉框需指定styleClass="dselect")
 * 如需要指定下拉框变成readonly样式，则在jsp定义下拉框： <html:select name="SS" styleClass="dselect">或<select name="SS" readonly>
 * 参数：String or Object，目标名称或对象，缺省为body对象
 *           
 * e.g. :  generateStyle(); // 将整个页面的所有控件设置为默认样式
 *         generateStyle("testDIV"); // 将“testDIV”区域的所有控件设置为默认样式
 */
function generateStyle(_target) {
    if (!_target && document.body) _target = document.body;
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (_target) {
        var _allInput = _target.getElementsByTagName("INPUT");
        for (var i = 0; i < _allInput.length; i++) {
			if (_allInput[i].disabled) {
			    setStyle(_allInput[i], true, false, _allInput[i].className);
			} else if (_allInput[i].readOnly) {
			    setStyle(_allInput[i], false, true, _allInput[i].className);
			} else {
			    setStyle(_allInput[i], false, false, _allInput[i].className);
			}
		}
		
		var _allSelect = _target.getElementsByTagName("SELECT");
        for (var i = 0; i < _allSelect.length; i++) {
        	var _className = _allSelect[i].className;
            if (_allSelect[i].disabled) {
			    setStyle(_allSelect[i], true, false, _className);
			} else if (_className == "dselect" || _allSelect[i].readOnly || _allSelect[i].readonly == "") {
			    setStyle(_allSelect[i], false, true, _className);
			} else {
			    setStyle(_allSelect[i], false, false, _className);
			}
		}
    }
}

/**
 * 为指定Table的每一行生成序号
 * 
 * 参数： String， 目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  generateTableSerial(); // 自动生成“dynamicTT”的序号
 *           generateTableSerial("myTable") // 自动生成“myTable”的序号
 */
function generateRowSerial(_target) {
	if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }

    if (_target) {
        var _count = _target.rows.length;
    	var _ex = 1;
        for(var i = 0; i < _count; i++){
        	// 如果为样式行，忽略
        	if (_target.rows[i].id == "layoutTR") {
        		_ex = 0;
        		continue;
        	}

            _target.rows[i].cells[0].innerText = i+_ex;
        }
    }
}

/**
 * 为指定Table的每行显示交替显示背景色(注意:页面html里每个td里不能指定bgcolor属性)
 * 
 * 参数： String， 目标table的名字，缺省为“dynamicTT”
 *       Array,   存放两个交替的颜色值
 *       boolean, 是否自动设置文本框的背景色和tr相同（暂停使用）
 *           
 *   e.g. :  generateRowBgColor();  // 自动生成“dynamicTT”每行交替显示背景色
 *           generateRowBgColor("myTable") // 自动生成“myTable”每行交替显示背景色
 *           generateRowBgColor("myTable", new Array(""#FFFFFF"", ""#000000"")) //自动生成“myTable”每行交替显示黑白背景色
 */
function generateRowBgColor(_target, _colors, _showText) {
	if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }

    if (_target) {
    
    	if (!_colors) {
        	_colors = new Array("D7E6F4", "#FFFFFF");
    	}
    
        var _colorIdx = 0;
        var _sameCount = 0;
        for(var i = 0; i < _target.rows.length; i++) {
            var _row = _target.rows[i];
            
            //鼠标点击TR时开启键盘控制高亮显示行
            if (!_row.onclick) {
            	_row.onclick = function() {controlTable(false, HIGHLIGHT_ROWIDX, _target); controlTable(true, this.rowIndex, _target)}
            }
            
        	// 如果为样式行，忽略
        	if (_row.id == "layoutTR") continue;
        	
        	for (var j = 0; j < _row.cells.length; j++) {
        	    var _cell = _row.cells[j];
        	    if (_cell.bgColor || _cell.style.backgroundColor) {
        	        _cell.bgColor = "";
        	        _cell.style.backgroundColor = "";
        	    }
        	    if (!_sameCount && _cell.rowSpan && _cell.rowSpan > 1) {
        	        _sameCount = _cell.rowSpan;
        	        _colorIdx = ++_colorIdx % 2;
        	    }
        	}
        	
        	if (_sameCount) {
                _row.style.backgroundColor = _colors[_colorIdx];
                _sameCount--;
            } else {
                _row.style.backgroundColor = _colors[(++_colorIdx) % 2];
            }
            
            //将当前行的背景色保存到自定义属性“originalBgColor”中
            _row.originalBgColor = _row.style.backgroundColor;

			// 使用自适应背景色文本框后无需该操作
    		/* if (!_showText) {
    			var _texts = _target.rows[i].getElementsByTagName("INPUT");
			    for (var j = 0; j < _texts.length; j++) {
			        _texts[j].style.backgroundColor = _colors[(i+1) % 2];
			    }
		    }
		    */
		}
    }
}

/**
 * 为指定Table的每一行控件改名成统一的“list[n].item”的格式
 * 
 * 参数： String， 目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  generateRowObjName(); // 自动为“dynamicTT”的每一行控件改名
 *           generateRowObjName("myTable") // 自动为“myTable”的每一行控件改名
 */
function generateRowObjName(_target) {
	if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (_target) {
        var _count = _target.rows.length;
    	var _ex = 0;
        for(var i = 0; i < _count; i++) {
        	var _row = _target.rows[i];
        	// 如果为样式行，忽略
        	if (_row.id == "layoutTR") {
        		_ex = 1;
        		continue;
        	}
            var _texts = _row.getElementsByTagName("INPUT");
            if (_texts && _texts.length) {
	            for(var j = 0; j < _texts.length; j++) {
	            	changeObjName(_texts[j], _row.rowIndex-_ex);
	            }
            }
        }
    }
}

/**
 * 重置指定table的行号，交替背景色及table里所有控件的name
 * 
 * 参数： boolean，是否重置table里所有控件的名字
 *       String， 目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  resetTable(); // 重置“dynamicTT”的行号，交替背景色（动态新增一行后可以这样调用）
 *           resetTable(true); // 重置“dynamicTT”的行号，交替背景色，并将其内所有控件统一改名（动态删除一行后可以这样调用）
 *           resetTable(true, "myTable") // 重置“myTable”的行号，交替背景色，并将其内所有控件统一改名
 */
function resetTable(_resetName, _target) {
	if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (_target) {
    	if (_resetName) {
    		generateRowObjName(_target);
    	}
    	generateRowSerial(_target);
    	generateRowBgColor(_target);
    }
}

/**
 * 设置合并单元格
 * 
 * 参数： Array， 目标单元格（TD）的序号，从0开始
 *       String, 目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  generateRowSpan(new Array(1,3,5));  // “dynamicTT”表格的第1，3，5列进行设置rowSpan
 *           generateRowSpan(new Array('1'), "myTable") // “myTable”表格的第1列进行设置rowSpan
 */
function generateRowSpan(_tdIdxs, _target) {
	if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    if (_target && _target.rows.length > 1) {
	    if (!_tdIdxs || !(_tdIdxs instanceof Array) || _tdIdxs.length == 0) {
	    	_tdIdxs = new Array();
	    	for(var i = 0; i < _target.rows[0].cells.length; i++) {
	    		_tdIdxs[i] = i;
	    	}
	    }
	    
	    var _lRowIdx = 0;
	    for(var i = 1; i < _target.rows.length; i++) {
	        
            var _row = _target.rows[i];
            var _lRow = _target.rows[_lRowIdx];
            var _delTdCount = 0;  
            
			for(var j = 0; j < _tdIdxs.length; j++) {
				var _cellIdx = _tdIdxs[j];

				var _cell = _row.cells[_cellIdx - _delTdCount];
				var _lCell = _lRow.cells[_cellIdx];

				if (_cell.innerHTML.trim() == _lCell.innerHTML.trim()) {
				    _lCell.rowSpan = _lCell.rowSpan ? _lCell.rowSpan+1 : 2;
				    _row.deleteCell(_cellIdx - _delTdCount);
				    _delTdCount++;
				}
		    }
		    if (_delTdCount == 0) {_lRowIdx = i}
		}
	}
}

/**
 * 在页面第一个form里找到所有匹配_name的控件
 * 
 * 参数： String， 需匹配的字符串
 *           
 *   e.g. :  queryElements("order");  // 找到页面第一个form里所有名字中有“order”的控件
 */
function queryElements(_name){
	var _allObjs = document.forms[0].elements;

	var _elements = _allObjs.elements;
	var _findElems = new Array();

	var index = 0;
	for(var i=0;i<_elements.length;i++){
		_obj = _elements[i];

		if(_obj.name && _obj.name.indexOf("Disabled.") !=0 && _obj.name.indexOf(_name) >= 0){
			_findElems[index] = _obj;
			index++;
		}
	}
	return _findElems;
}

/**
 * 校验输入行号
 * 
 * 参数：String，行号输入框，缺省为“operateId”
 *       String, 目标table的名字，缺省为“dynamicTT”
 * 返回：boolean，true：校验通过；false：校验不通过
 *           
 *   e.g. :  checkLineNumber();  // 校验对应“dynamicTT”表格输入的行号是否正确
 *           checkLineNumber("linenum", "myTable") // “myTable”表格的第1列进行设置rowSpan
 */
function checkLineNumber(_input, _table) {
	if (!_input) _input = "operateId";
	if ("string" == typeof(_input)) {
        _input = document.getElementById(_input);
    }
    
	if (!_table) _table = "dynamicTT";
    if ("string" == typeof(_table)) {
        _table = document.getElementById(_table);
    }
    
	if (_input.value.trim() == "") {
		alert("请输入行号！");
		setFocus(_input);
		return false;
	}
	if (!checkInteger(_input.value)) {
		alert("您输入的行号不是数字，请重新输入！");
		setFocus(_input);
		return false;
	}
	
	var _tableRows = _table.rows.length;
	var _txt = _table.rows[0].cells[0].innerText;
	if (_table.rows[0].id == "layoutTR" || (_txt && !_table.rows[0].cells[0].innerText.trim())) {
		_tableRows--;
	}
	
	if (parseInt(_input.value) < 1 || parseInt(_input.value) > _tableRows) {
		alert("您输入的行号有误，请重新输入！");
		setFocus(_input);
		return false;
	}
	return true;
}

/**
 * 改变打印状态（用于打印备货单等状态栏打“√”）
 * 
 * 参数：int，     1：更改单行 2：更改全部 3：更改部分
 *       int，     要修改的单元格所在列的序号
 *       int，     参考分组的单元格所在列的序号(type为“2”和“3”时使用)
 *       String[]，参考分组的对应hidden的name集合(type为“3”时使用)
 *       String，  行号输入框，缺省为“operateId”
 *       String，  目标table的名字，缺省为“dynamicTT”
 *           
 *   e.g. :  changePrintStatus(1, 5)       //单行打勾
 *           changePrintStatus(2, 7);      //全部打勾（没有合并单元格的情况）
 *			 changePrintStatus(2, 7, 5);   //根据第5列的合并单元格情况来全部打勾
 *           changePrintStatus(3, 7, 5, new Array('hidA','hidB'...))    //根据第5列的值过滤部分行打勾
 *           changePrintStatus(3, 7, 5, new Array('hidA','hidB'...), "lineNum", "myTalbe") //根据第5列的值过滤部分行打勾（自己指定行号控件和table）
 */
function changePrintStatus(_type, _colIdx, _refcolIdx, _refHidProps, _lineNumObj, _target) {
	if (!_target) _target = "dynamicTT";
    if ("string" == typeof(_target)) {
        _target = document.getElementById(_target);
    }
    
    if (!_lineNumObj) _lineNumObj = "operateId";
    if ("string" == typeof(_lineNumObj)) {
        _lineNumObj = document.getElementById(_lineNumObj);
    }
    
    var _value = "<b><font size='4' color='green'>√</font></b>";
    
	if (_colIdx == "undefined") {
		_colIdx = 6;
	}
	//单个打印
	if (_type == 1) {
		setCellValue(_value, _lineNumObj.value-1, _colIdx, _target);
		return;
	}
	
	//全部打印
	if (_type == 2) {
		
		if (!_refcolIdx) {
			_refcolIdx = 0;
		}
		
		var _rowSpan = 0;
		
		for (var i = 0; i < _target.rows.length; i++){
			var _cell = _target.rows[i].cells[_refcolIdx];
	    	if (_rowSpan > 1) {
    			setCellValue(_value, i, _colIdx-1, _target);
    			_rowSpan--;
    		} else {
    			if (_cell.rowSpan > 1) {
					_rowSpan = _cell.rowSpan;
				}
				setCellValue(_value, i, _colIdx, _target);
			}
		}
		return;
	}
	
	//按被货受理号或提货编号打印
	if (_type == 3) {
		var _ref = "";
		for (var i = 0; i < _refHidProps.length; i++) {
			var _refHidProp = _refHidProps[i].replace(".", "[" + (_lineNumObj.value-1) + "].");
			_ref += " " + document.getElementById(_refHidProp).value;
		}
		
		var _rowSpan = 0;
		for (var i = 0; i < _target.rows.length; i++){
			var _cell = _target.rows[i].cells[_refcolIdx];
			
			if (_rowSpan > 1) {
    			setCellValue(_value, i, _colIdx-1, _target);
    			_rowSpan--;
    		} else if (_ref.trim() == _cell.innerText.trim()) {
				if (_cell.rowSpan > 1) {
					_rowSpan = _cell.rowSpan;
				}
				setCellValue(_value, i, _colIdx, _target);
			}
		}
	}
}

/**
 * 功能：检查是否为整型
 * 用法：checkInteger(form.txtName.value)
 * 说明：
 */
function checkInteger(inputVal)
{
    var inputStr = inputVal.toString();

    for (var i = 0; i < inputStr.length; i ++ )
    {
        var oneChar = inputStr.charAt(i);
        if (i == 0 && (oneChar == "-") )
        {
            if (inputStr.length == 1 )
            {
                return false;
            }else{
                continue;
            }
        }

        //if(oneChar == ",")
        //{
            //continue;
        //}

        if (oneChar < "0" || oneChar > "9")
            return false;
    }
    return true;
}

/**
 * 功能：检查是否是浮点数
 * 用法：checkNumber(form.txtName.value)
 * 说明：
 */
function checkNumber(input)
{
    var oneDecimal = false;
    var inputVal = input.toString();

    for (var i = 0; i < inputVal.length; i ++ )
    {
        var oneChar = inputVal.charAt(i);

        if (i == 0 && (oneChar == "+" || oneChar == "-") )
        {
            if (inputVal.length == 1 )
            {
                 return false;
            }
            else continue;
        }
        if (oneChar == "." && !oneDecimal) {
            oneDecimal = true;
            continue;
        }
        if(oneChar == ",")
        {
            continue;
        }
        if (oneChar < "0" || oneChar > "9")
        {
             return false;
        }
    }
    return true;
}

/**
 * 功能：得到两个日期相差天数
 * 用法：getTwoDateDays("20070401","20070408")
 * 说明：返回两个日期之间的天数
 * 作者：鲍利兵
 * 日期：20070412
 */
function getTwoDateDays(startDate, endDate){
	var sDate = new Date(startDate.substring(0,4), startDate.substring(4,6)-1, startDate.substring(6));
	var eDate = new Date(endDate.substring(0,4), endDate.substring(4,6)-1, endDate.substring(6));
	//alert(sDate);
	//alert(eDate);		
	var times = eDate.getTime() - sDate.getTime();
	
	var MinMilli = 1000 * 60;
	var HrMilli = MinMilli * 60;
	var DyMilli = HrMilli * 24;
	
	return times / DyMilli;
}

function $(arg0) {
	if (isString(arg0)) {
		var o;
		o = document.getElementById(arg0);
		if (isUndefined(o) || isNull(o)) {
			o = document.getElementsByName(arg0)[0];
		}
		return o;
	} else {
		return arg0;
	}
}

onGoPage=function(pageno,pageCount,url){
	var form = document.forms[0];
	for(var i=0 ; i< pageno.length ;i++){
		if(pageno.charAt(i)<'0'||pageno.charAt(i)>'9'){
			pageno=-1
			break
		}
	}
	if(pageno<=0||pageno>pageCount){
		return
	}
	form.pageNo.value = pageno;
	var tmpUrl=form.action;
	form.action=url;
	form.submit();
	form.action=tmpUrl;
}

function isDiv(arg0) {
	return arg0.tagName.toLowerCase() == "div";
}
function isInput(arg0) {
	return arg0.tagName.toLowerCase() == "input";
}
function isText(arg0) {
	return arg0.type.toLowerCase() == "text";
}
function isButton(arg0) {
	return arg0.type.toLowerCase() == "button";
}
function isCheckbox(arg0) {
	return arg0.type.toLowerCase() == "checkbox";
}
function isRadio(arg0) {
	return arg0.type.toLowerCase() == "radio";
}
function isSelect(arg0) {
	return arg0.tagName.toLowerCase() == "select";
}
function isMultiple(arg0) {
	if (isBoolean(arg0.multiple) && arg0.multiple == true) {
		return true;
	}
	if (isString(arg0.multiple)) {
		if (arg0.multiple.toLowerCase() == "multiple" || arg0.multiple.toLowerCase() == "true") {
			return true;
		}
	}
}
function isTextarea(arg0) {
	return arg0.tagName.toLowerCase() == "textarea";
}
function isAlien(a) {
	return isObject(a) && typeof a.constructor != "function";
}
function isArray(a) {
	return isObject(a) && a.constructor == Array;
}
function isBoolean(a) {
	return typeof a == "boolean";
}
function isEmpty(o) {
	var i, v;
	if (isObject(o)) {
		for (i in o) {
			v = o[i];
			if (isUndefined(v) && isFunction(v)) {
				return false;
			}
		}
	}
	if (isString(o) && o.trim() != "") {
		return false;
	}
	return true;
}
function isFunction(a) {
	return typeof a == "function";
}
function isNull(a) {
	return typeof a == "object" && !a;
}
function isNumber(a) {
	return typeof a == "number";
}
function isObject(a) {
	return (a && typeof a == "object") || isFunction(a);
}
function isString(a) {
	return typeof a == "string";
}
function isTag(a) {
	return (a.nodeType && a.nodeType == 1);
}
function isUndefined(a) {
	return typeof a == "undefined";
}
function $all(arg0) {
	if (isString(arg0)) {
		var o;
		o = document.getElementsByName(arg0);
		return o;
	} else {
		return arg0;
	}
}
function removeElementFromDOM(id) {
	var element = $(id);
	return element.parentNode.removeChild(element);
}
function isIE() {
	if (document.all) {
		return true;
	} else {
		return false;
	}
}
/**
 * 获取指定元素的所有子元素
 * 返回的数组已剔出注释节点
 * arg0 对象的id或者name或者元素本身
 * arg1 元素的tagName，只要子元素的tagName == arg1的时候才会被返回
 */
function getAllChildNodes(arg0, arg1) {
	var o = new Array();
	arg0 = $(arg0);
	if (isNull(arg0)) {
		return null;
	} else {
		for (var i = 0; i < arg0.childNodes.length; i++) {
			if (!isUndefined(arg0.childNodes[i].tagName)) {
				if (arg1) {
					if (arg0.childNodes[i].tagName) {
						if (arg0.childNodes[i].tagName.toLowerCase() == arg1.toLowerCase()) {
							o.push(arg0.childNodes[i]);
						}
					}
				} else {
					o.push(arg0.childNodes[i]);
				}
			}
		}
		return o;
	}
}
function $getVal(arg0) {
	arg0 = $(arg0);
	var list;
	var list2;
	if (!isNull(arg0)) {
		if (isDiv(arg0)) {
			return arg0.innerHTML;
		} else {
			if (isInput(arg0)) {
				if (isEmpty(arg0.type)) {
					return null;
				} else {
					if (isText(arg0) || isButton(arg0)) {
						return arg0.value;
					} else {
						if (isCheckbox(arg0)) {
							if (arg0.checked == true) {
								return arg0.value;
							} else {
								return null;
							}
						} else {
							if (isRadio(arg0)) {
								if (isEmpty(arg0.name)) {
									return null;
								} else {
									list = $all(arg0.name);
									for (var i = 0; i < list.length; i++) {
										if (list[i].checked == true) {
											return list[i].value;
										}
									}
									return null;
								}
							}
						}
					}
				}
			} else {
				if (isSelect(arg0)) {
					list = getAllChildNodes(arg0, "option");
					list2 = new Array();
					for (var i = 0; i < list.length; i++) {
						if (list[i].selected == true) {
							list2.push(list[i].value);
						}
					}
					return list2;
				} else {
					if (isTextarea(arg0)) {
						return arg0.innerHTML;
					}
				}
			}
		}
	} else {
		return null;
	}
}
function $setVal(arg0, arg1) {
	arg0 = $(arg0);
	var list;
	var matchingFlag = 0;
	if (!isNull(arg0)) {
		if (isDiv(arg0)) {
			arg0.innerHTML = arg1;
			return 1;
		} else {
			if (isInput(arg0)) {
				if (isEmpty(arg0.type)) {
					return null;
				} else {
					if (isText(arg0) || isButton(arg0)) {
						arg0.value = arg1;
						return 1;
					} else {
						if (isCheckbox(arg0)) {
							if (arg1 == true || arg1 == "true") {
								arg0.checked = true;
								return 1;
							} else {
								if (arg1 == "false" || arg1 == false) {
									arg0.checked = false;
									return 1;
								} else {
									arg0.checked = true;
									return 1;
								}
							}
						} else {
							if (isRadio(arg0)) {
								if (isEmpty(arg0.name)) {
									return null;
								} else {
									list = $all(arg0.name);
									for (var i = 0; i < list.length; i++) {
										if (list[i].value == arg1) {
											list[i].checked = true;
											return 1;
										}
									}
									return null;
								}
							}
						}
					}
				}
			} else {
				if (isSelect(arg0)) {
					list = getAllChildNodes(arg0, "option");
					if (isString(arg1)) {
						for (var i = 0; i < list.length; i++) {
							if (list[i].value == arg1) {
								list[i].selected = true;
								return 1;
							}
						}
					} else {
						if (isArray(arg1)) {
			//附值方式是先select的option和参数匹配，完全匹配的话就进行select的option选中，否则不作任何选中
							if (!isMultiple(arg0)) {
								return null;
							}
							for (var i = 0; i < arg1.length; i++) {
								for (var j = 0; j < list.length; j++) {
									if (arg1[i] == list[j].value) {
										matchingFlag = 1;
									}
								}
								if (matchingFlag == 1) {
									matchingFlag = 0;
								} else {
									return null;
								}
							}
							for (var i = 0; i < arg1.length; i++) {
								for (var j = 0; j < list.length; j++) {
									if (arg1[i] == list[j].value) {
										list[j].selected = true;
									}
								}
							}
							return 1;
						}
					}
					return null;
				} else {
					if (isTextarea(arg0)) {
						arg0.innerHTML = arg1;
						return 1;
					}
				}
			}
		}
	} else {
		return null;
	}
}


/**
 * 动态增加新行普通用法
 *   e.g. :  copytr()(普通的用法，新增行后清空其所有控件的值,默认每次新增1行，允许增加到20行);
 */
function copytr() {
    return copyrow(new Array('ALL', 'value', null));
}

/**
 * 动态增加新行的改进函数
 * 需要指定页面所操作table的ID为“dynamicTT”
 * 参数1~n ： 数组，格式为{系统参数（如‘ONCEROWS’，‘MAXROWS’等），参数值 [，补充内容(如超出最大行数后的提示信息)]}
 *                 或者{ 控件Name（“ALL”为该新增行所有控件），控件js属性名，控件js属性值 }
 *           
 *   e.g. :  copyrow();（如果参数缺省则默认显示每行序号；每次新增1行;允许增加到20行;并将上一行所有控件的值继承过来）
 *           copyrow(new Array('ALL', 'value', null))（指定新增行中所有控件的value为空）
 *           copyrow(new Array('ONCEROWS',5))（指定每次增加5行）
 *           copyrow(new Array('MAXROWS',10))（指定只能允许增加到10行）
 *           copyrow(new Array('SHOWLINENO',false))（不显示每行序号）
 *           copyrow(new Array('colgzxmmc','readOnly',false),new Array('colJjdw','readOnly',false))（指定新增行中colgzxmmc和colJjdw控件的readOnly属性为false）
 *           copyrow(new Array('colgzxmmc','readOnly',true))（指定新增行中colgzxmmc控件的disabled属性为true）
 *           ...
 */
function copyrow()
{
    var _dynamicTT = document.all.dynamicTT;
    var _maxrows = 20; //默认最大行数为20
    var _message = null;
    var _oncerows = 1; //默认每次新增1行
    var _showlineno = true; //默认显示每行序号
    for (var i = 0; i < arguments.length; i++) {
        if (arguments[i][0] == "MAXROWS") {
            _maxrows = arguments[i][1];
            _message = arguments[i][2];
        }
        if (arguments[i][0] == "ONCEROWS") {
            _oncerows = arguments[i][1];
        }
        if (arguments[i][0] == "SHOWLINENO") {
            _showlineno = arguments[i][1];
        }
    }
    
    var _rowSpan = _dynamicTT.rows[0].firstChild.rowSpan;
	if (!_rowSpan) _rowSpan = 1;
	
    var _remain = _maxrows - (_dynamicTT.rows.length - _rowSpan);
	if (_remain <= 0) {
	    if (!_message) _message = "为了保证数据的安全提交，您最多只能增加到" + _maxrows + "行。";
	    alert(_message);
	} else {
	    if (_oncerows > _remain) _oncerows = _remain;
        for (var i = 0; i < _oncerows; i++) {
            copyrow_sub(arguments);
        }
	    
	    // 重新生成序号
	    if (_showlineno) generateSequenceNo();
    }
}

/**
 * private function
 * 动态增加新行的子函数(仅供copyrow()函数调用)
 */
function copyrow_sub(_arg)
{
    var _dynamicTT = document.all.dynamicTT;
    var _oCloneTR = _dynamicTT.firstChild.lastChild.cloneNode(true);
    // 插入新行
    _dynamicTT.firstChild.insertBefore(_oCloneTR);

    var _allInput = _oCloneTR.getElementsByTagName("INPUT");
    var _focus = false;
    for (var i = 0; i < _allInput.length; i++) {
        if (!_focus) {
	        try {
	            _allInput[i].focus();
                _focus = true;
	        } catch (e) {
	        }
        }
        for (var j = 0; j < _arg.length; j++) {
            if (_arg[j][0] == "ALL" || _arg[j][0] == _allInput[i].name) {
                if (!_arg[j][2]) {
                    eval("_allInput[i]." + _arg[j][1] + " = ''");
                } else {
                    eval("_allInput[i]." + _arg[j][1] + " = '" + _arg[j][2]+ "'");
                }
            }
        }
    }

    var _allSelect = _oCloneTR.getElementsByTagName("SELECT");

    for (var i = 0; i < _allSelect.length; i++) {
        var _inherit = true;
        for (var j = 0; j < _arg.length; j++) {
            if (_arg[j][0] == "ALL" || _arg[j][0] == _allSelect[i].name) {
                if (!_arg[j][2]) {
                    if (_arg[j][1] == "value") {
                        _inherit = false;
                    } else {
                        eval("_allSelect[i]." + _arg[j][1] + " = ''");
                    }
                } else {
                    eval("_allSelect[i]." + _arg[j][1] + " = '" + _arg[j][2] + "'");
                }
            }
        }
        if (_inherit) {
            var _objs = eval("document.all." + _allSelect[i].name);
            _allSelect[i].selectedIndex = _objs[_objs.length-2].selectedIndex;
        }
    }
}

/**
 * 删除一行
 */
function deltr(){
    var _dynamicTT = document.all.dynamicTT;
    var _radio = document.all.radio;
    
    if ((isNaN(_radio.length) && _radio.checked) || (_radio.length == 1 && _radio[0].checked)) {
        alert("不能删除该行！");
        return;
    }
    
    var _showlineno = true; //默认显示每行序号
    for (var i = 0; i < arguments.length; i++) {
        if (arguments[i][0] == "SHOWLINENO") {
            _showlineno = arguments[i][1];
        }
    }
    
    var _rowSpan = _dynamicTT.rows[0].firstChild.rowSpan;
    if (!_rowSpan) _rowSpan = 1;
    
    for(var i= 0 ; i < _radio.length; i++){
        if(_radio[i].checked){
	        if (confirm("确认要删除此行吗？")) {
	            _dynamicTT.deleteRow(i+_rowSpan);
	            // 重新生成序号
                if (_showlineno) generateSequenceNo();
	            return;
            } else {
                return;
            }
        }
    }
    alert("请选择要删除的行！");
}

/**
 * 为指定Table“dynamicTT”的每一行生成序号
 */
function generateSequenceNo() {
    var _dynamicTT = document.all.dynamicTT;
    var _rowSpan = _dynamicTT.rows[0].firstChild.rowSpan;
    var _count = 0;
    
    if (!_rowSpan) _rowSpan = 1;
    
    _count = _dynamicTT.rows.length - _rowSpan;
    
    for(var i = 1; i <= _count; i++, _rowSpan++){
        _dynamicTT.rows[_rowSpan].firstChild.innerHTML = i;
    }
}

/**
 * 清空指定区域中所有控件的值
 * 参数： String，指定form的name或者table的id
 *           
 * e.g. :  clearValue('targetTT') or clearValue('targetForm')   // 清空“targetTT”表或“targetForm”表单里所有的控件值
 *         clearValue('targetTT', new Array('ssdw', 'ZT', ...)) // 清空“targetTT”表里除name为“ssdw”和“ZT”外所有的控件值
 * 
 */
function clearValue(_target, _exclude)
{
    var _target = eval("document.all." + _target);
    var _allInput = _target.getElementsByTagName("INPUT");
    Outer1:
    for (var i = 0; i < _allInput.length; i++) {
        if (_exclude) {
	        for (var j = 0; j < _exclude.length; j++) {
	            if (_exclude[j] == _allInput[i].name) continue Outer1;
	        }
        }
        _allInput[i].value = '';
    }

    var _allSelect = _target.getElementsByTagName("SELECT");
    
    Outer2:
    for (var i = 0; i < _allSelect.length; i++) {
        if (_exclude) {
            for (var j = 0; j < _exclude.length; j++) {
                if (_exclude[j] == _allSelect[i].name) continue Outer2;
            }
        }
        _allSelect[i].selectedIndex = 0;
    }
}

/**
 * 功能：得到字符串的字节长度，如果含有中文则一个中文占用两个字节长度
 * 参数：需要处理的字符串
 * 返回：字符串的字节长度
 * 作者：鲍利兵          
 * 示例：getStrByteLength("测试test测 试100") 将返回 16
 * 
 */
function getStrByteLength(str){	
	//预期计数：中文2字节，英文1字节
	var a = 0;	
	//循环计数
	var i = 0;	
	for (i=0;i<str.length;i++){
		if (str.charCodeAt(i)>255){			
			//按照预期计数增加2
			a+=2;
		}else{
			a++;
		}	
	}
	//如果全部是单字节字符，就直接返回源字符串
	return a;
}

/**
 * 功能：得到指定长度的字符串，如果含有中文则一个中文占用两个字节长度
 * 参数：需要处理的字符串，待返回字符串的长度
 * 返回：返回指定长度的字符串
 * 作者：鲍利兵          
 * 示例：getStrByByteLength("测试test测 试100",6) 将返回 "测试te"
 * 
 */
function getStrByByteLength(str, len){
	if(!str || !len) { 
		return ''; 
	}
	//预期计数：中文2字节，英文1字节
	var a = 0;	
	//循环计数
	var i = 0;	
	//临时字串
	var temp = '';
	for (i=0;i<str.length;i++){
		if(str.charCodeAt(i)>255){
			//按照预期计数增加2
			a+=2;
		}else{
			a++;
		}	
		//如果增加计数后长度大于限定长度，就直接返回临时字符串
		if(a > len) { 
			return temp; 
		}
		//将当前内容加到临时字符串
		temp += str.charAt(i);
	}
	//如果全部是单字节字符，就直接返回源字符串
	return str;
}

/**
 * 功能：将字符串中含有的半角字符转换成全角字符
 * 参数：需要处理的字符串
 * 返回：已处理的字符串
 * 作者：鲍利兵          
 * 示例：transformDBC2SBC("测试test测 试100")将返回"测试ｔｅｓｔ测　试１００"
 * 
 */
function transformDBC2SBC(transformStr){
	var tmp = "";
    for(var i=0;i<transformStr.length;i++){
		var unicode = transformStr.charCodeAt(i);
		if(unicode < 256){
			if(unicode == 32){
				tmp += String.fromCharCode(12288);	
			}else{
				tmp += String.fromCharCode(unicode + 65248);	
			}
		}else{
			tmp += String.fromCharCode(unicode);	
		}
    }
    return tmp;
}