// 当鼠标单击分组属性前的图标时，显示或隐藏此分组下的所有行
// @param thisObj 点击的图形
// @param thisEvent 点击生成的事件，暂时没有使用
function expandFieldGroup(thisObj, thisEvent) {
    if (!thisObj) return;
    //获得包含此图形的表格对象
    var table= thisObj.parentNode.parentNode.parentNode.parentNode;
    if (!table) return;
    var src= thisObj.src;
    //获得此图形的文件目录，改变分组图标的图形文件
    var index= src.lastIndexOf("/");
    var srcBase= src.substring(0,index);
    var iconName = src.substring(index+11,index+12);
    if (iconName=="C") {
        thisObj.src= srcBase + "/fieldGroupOpen.gif";
        thisObj.alt="展开";
    } else {
        thisObj.src= srcBase + "/fieldGroupClose.gif";
        thisObj.alt="合并";
    }
    //根据需要展开或合并所有下级行
    var rowId= thisObj.id;
    var rows= table.rows;
    var rowCount= rows.length;
    for (var i=0; i<rowCount; i++) {
        if (rows[i].id == rowId) {
            if (iconName=="C") {
                rows[i].style.display="none";
            } else {     
                rows[i].style.display="block";
            }
        }
    }
}

//-----------------------------------------------------------------------------
// 以下方法为判断字符串是否可以转换为其它类型的方法，入参为String
//-----------------------------------------------------------------------------

// 判断一个字符串是否是有效的日期，是有效的日期返回true否则返回false，
// 支持的日期格式为yyyy-mm-dd、yyyy年mm月dd日。
// @param value 需要进行判断的字符串
// @return 是有效的日期返回true否则返回false
function isDate(value) {
    //首先判断参数有效性
    if (value == "") return true;
    if (arguments.length != 1) return false;
    if (!value) return false;
    //首先根据格式yyyy-mm-dd进行判断
    var reg_dts= /^(\d{4})\-(\d{1,2})\-(\d{1,2})$/;
    var reg_dtl= /^(\d{4})\年(\d{1,2})\月(\d{1,2})\日$/;
    //检验日期格式
    if (!reg_dts.test(value) && !reg_dtl.test(value)) return false;
    //检验年范围
	if (RegExp.$1 > 3000 || RegExp.$1 <1901) return false;
	//检验月范围
	if (RegExp.$2 >12 || RegExp.$2 < 1) return false;
	//检验日范围
	if (RegExp.$3 > 31 || RegExp.$3 <1) return false;
	//检验一个月中的天数
	var dt_test = new Date(RegExp.$1, Number(RegExp.$2-1), RegExp.$3);
	if (dt_test.getMonth() != Number(RegExp.$2-1)) return false;
	return true;
}

// 判断一个字符串是否是有效的时间，是有效的时间返回true否则返回false，
// 支持的时间格式为hh:mm:ss、hh时mm分ss秒，时间为24小时制。
// @param value 需要进行判断的字符串
// @return 是有效的时间返回true否则返回false
function isTime(value) {
    //首先判断参数有效性
    if (arguments.length != 1) return false;
    if (!value) return false;
    if (value == "") return false;
    //两种时间格式的正则表达式
    var reg_tms= /^(\d{1,2})\:(\d{1,2})\:(\d{1,2})$/;
    var reg_tml= /^(\d{1,2})\时(\d{1,2})\分(\d{1,2})\秒$/;
    //检查日期格式
    if (!reg_tms.test(value) && !reg_tml.test(value)) return false;
	//检查时、分、秒的范围
	if (RegExp.$1 > 23 || RegExp.$2 > 59 || RegExp.$3 > 59) return false;
	return true;
}

// 判断一个字符串是否是有效的日期时间型，是返回true否则返回false，
// 支持的格式为yyyy-mm-dd hh:mm:ss、yyyy年mm月dd日hh时mm分ss秒 。
// @param value 需要进行判断的字符串
// @return 是有效的日期时间返回true否则返回false
function isTimestamp(value) {
    //首先判断参数有效性
    if (arguments.length != 1) return false;
    if (!value) return false;
    if (value == "") return false;
    //首先根据格式yyyy-mm-dd hh:mm:ss进行判断
    var reg_dts= /^(\d{4})\-(\d{1,2})\-(\d{1,2})\ (\d{1,2})\:(\d{1,2})\:(\d{1,2})$/;
    var reg_dtl= /^(\d{4})\年(\d{1,2})\月(\d{1,2})\日(\d{1,2})\时(\d{1,2})\分(\d{1,2})\秒$/;
    //检验日期格式
    if (!reg_dts.test(value) && !reg_dtl.test(value)) return false;
    //检验年范围
	if (RegExp.$1 > 3000 || RegExp.$1 <1901) return false;
	//检验月范围
	if (RegExp.$2 >12 || RegExp.$2 < 1) return false;
	//检验日范围
	if (RegExp.$3 > 31 || RegExp.$3 <1) return false;
    //检验一个月中的天数
	var dt_test = new Date(RegExp.$1, Number(RegExp.$2-1), RegExp.$3);
	if (dt_test.getMonth() != Number(RegExp.$2-1)) return false;
	//检验时间各个段的范围
	if (RegExp.$4 > 23 || RegExp.$5 > 59 || RegExp.$6 > 59) return false;
	return true;
}

// 判断一个字符串是否是有效的日期时间型，是返回true否则返回false，
// 支持的格式为yyyy-mm-dd hh:mm、yyyy年mm月dd日hh时mm分。
// @author xujin  2005-03-16
// @param value 需要进行判断的字符串
// @return 是有效的日期时间返回true否则返回false
function isTimestampNoSec(value) {
	if (value == "") return true;
    //首先判断参数有效性
    if (arguments.length != 1) return false;
    if (!value) return false;
    //if (value == "") return false;
    //首先根据格式yyyy-mm-dd hh:mm进行判断
   var reg_dts= /^(\d{4})\-(\d{1,2})\-(\d{1,2})\ (\d{1,2})\:(\d{1,2})$/;
    var reg_dtl= /^(\d{4})\年(\d{1,2})\月(\d{1,2})\日(\d{1,2})\时(\d{1,2})\分$/;
     //检验日期格式
    if (!reg_dts.test(value) && !reg_dtl.test(value)) return false;
    //检验年范围
	if (RegExp.$1 > 3000 || RegExp.$1 <1901) return false;
	//检验月范围
	if (RegExp.$2 >12 || RegExp.$2 < 1) return false;
	//检验日范围
	if (RegExp.$3 > 31 || RegExp.$3 <1) return false;
    //检验一个月中的天数
	var dt_test = new Date(RegExp.$1, Number(RegExp.$2-1), RegExp.$3);
	if (dt_test.getMonth() != Number(RegExp.$2-1)) return false;
	//检验时间各个段的范围
	if (RegExp.$4 > 23 || RegExp.$5 > 59) return false;
	return true;
}

// 判断一个字符串是否是有效的日期时间型，是返回true否则返回false，
// 支持的格式为yyyy-mm-dd hh:mm、yyyy年mm月dd日hh时mm分。
// @author xujin  2005-03-16
// @param value 需要进行判断的字符串
// @return 是有效的日期时间返回true否则返回false
function isTimestampWithoutSecond(value) {
    //首先判断参数有效性
    if (arguments.length != 1) return false;
    if (!value) return false;
    if (value == "") return false;
    //首先根据格式yyyy-mm-dd hh:mm进行判断
    var reg_dts= /^(\d{4})\-(\d{1,2})\-(\d{1,2})\ (\d{1,2})\:(\d{1,2})$/;
    var reg_dtl= /^(\d{4})\年(\d{1,2})\月(\d{1,2})\日(\d{1,2})\时(\d{1,2})\分$/;
    //检验日期格式
    if (!reg_dts.test(value) && !reg_dtl.test(value)) return false;
    //检验年范围
	if (RegExp.$1 > 3000 || RegExp.$1 <1901) return false;
	//检验月范围
	if (RegExp.$2 >12 || RegExp.$2 < 1) return false;
	//检验日范围
	if (RegExp.$3 > 31 || RegExp.$3 <1) return false;
    //检验一个月中的天数
	var dt_test = new Date(RegExp.$1, Number(RegExp.$2-1), RegExp.$3);
	if (dt_test.getMonth() != Number(RegExp.$2-1)) return false;
	//检验时间各个段的范围
	if (RegExp.$4 > 23 || RegExp.$5 > 59) return false;
	return true;
}

// 判断一个字符串是否可以转换为一个无符号整数，是返回true否则返回false，
// @param value 需要进行判断的字符串
// @return 可以转换为一个无符号整数返回true否则返回false
function isUnsigned(value) {
    //首先判断参数有效性
    if (arguments.length != 1) return false;
    if (!value) return false;
    if (value == "") return false;
    var reg_unsigned= /^\d+$/;
    if (!reg_unsigned.test(value)) return false;
    return true;
}

// 判断一个字符串是否可以转换为一个整数，是返回true否则返回false，
// @param value 需要进行判断的字符串
// @return 可以转换为一个整数返回true否则返回false
function isInteger(value) {
    //首先判断参数有效性
    if (arguments.length != 1) return false;
    if (!value) return false;
    if (value == "") return false;
    var reg_integer= /^[\+\-]?\d*$/;
    if (!reg_integer.test(value)) return false;
    return true;
}

// 判断一个字符串是否可以转换为一个长整数，是返回true否则返回false，
// @param value 需要进行判断的字符串
// @return 可以转换为一个长整数返回true否则返回false
function isLong(value) {
    //首先判断参数有效性
    if (arguments.length != 1) return false;
    if (!value) return false;
    if (value == "") return false;
    var reg_long= /^[\+\-]?\d{1,19}$/;
    if (!reg_long.test(value)) return false;
    return true;
}


// 判断一个字符串是否可以转换为一个浮点数，是返回true否则返回false，
// @param value 需要进行判断的字符串
// @return 可以转换为一个浮点返回true否则返回false
function isFloat(value) {
    //首先判断参数有效性
    if (arguments.length != 1) return false;
    if (!value) return false;
    if (value == "") return false;
    var reg_float= /^[\+\-]?\d*\.?\d*$/;
    if (!reg_float.test(value)) return false;
    return true;
}

// 判断一个字符串是否是有效的年份，是返回true否则返回false，
// @param value 需要进行判断的字符串
// @return true或false
function isYear(value) {
    //首先判断参数有效性
    if (arguments.length != 1) return false;
    if (!value) return false;
    if (value == "") return false;
    var reg_year= /^(\d{4})$/;
    if (!reg_year.test(value)) return false;
    if (RegExp.$1 > 3000 || RegExp.$1 <1901) return false;
    return true;
}

// 判断一个字符串是否是有效的身份证号码，是返回ok否则返回错误原因。
// @param value 需要进行判断的字符串
// @return ok或错误原因
function checkIdCard(value) {
    if (!value) return "身份证号长度应该为15位或18位数字！";
    if (value.length == 15) {
        var yyyy, mm, dd;
        yyyy="19" + value.substring(6,8);
        mm= value.substring(8,10);
        dd= value.substring(10,12);
        if (mm>12 || mm<1) return "月份非法！";
        if (dd>31 || dd<1) return "日期非法！";
        return "ok";
    } else if (value.length == 18) {
        if (value.indexOf("X") > 0 && value.indexOf("X")!=17 || value.indexOf("x")>0 && value.indexOf("x")!=17)
            return "身份证中\"X\"输入位置不正确！";
        var yyyy, mm, dd;
        yyyy= value.substring(6,10);
        if (yyyy>2200 || yyyy<1900) return "年度非法！";
        mm= value.substring(10,12);
        if (mm>12 || mm<=0) return "月份非法！";
        dd= value.substring(12,14);
        if (dd>31 || dd<=0) return "日期非法！";
        if (value.charAt(17)=="x" || value.charAt(17)=="X") {
            if ("x" != getIdCardVerifyBit(value) && "X" != getIdCardVerifyBit(value))
                return "最后一位校验位错误！";
        } else{
            if (value.charAt(17) != getIdCardVerifyBit(value)) 
                return "最后一位校验位错误！";
        }
        return "ok";
    }
    return "身份证号长度应该为15位或18位数字！";
}

// 获得身份证号码的最后一位，即校验位
// @param value 需要进行判断的字符串
// @return 检验位
function getIdCardVerifyBit(value) {
    var result;
    var nNum= eval(value.charAt(0)*7+value.charAt(1)*9+value.charAt(2)*10+value.charAt(3)*5+value.charAt(4)*8+value.charAt(5)*4+value.charAt(6)*2+value.charAt(7)*1+value.charAt(8)*6+value.charAt(9)*3+value.charAt(10)*7+value.charAt(11)*9+value.charAt(12)*10+value.charAt(13)*5+value.charAt(14)*8+value.charAt(15)*4+value.charAt(16)*2);
    nNum= nNum%11;
    switch (nNum) {
       case 0 :
          result="1";
          break;
       case 1 :
          result="0";
          break;
       case 2 :
          result="X";
          break;
       case 3 :
          result="9";
          break;
       case 4 :
          result="8";
          break;
       case 5 :
          result="7";
          break;
       case 6 :
          result="6";
          break;
       case 7 :
          result="5";
          break;
       case 8 :
          result="4";
          break;
       case 9 :
          result="3";
          break;
       case 10 :
          result="2";
          break;
    }
    return result;
}

// 根据身份证号获得出生日期
// @param value 身份证号
// @return 出生日期，例如：1972-02-19
function getBirthdayByIdCard(value) {
    var result= "1901-01-01";
    if (!value) return result;
    var len= value.length;
    if (len == 15) {
        yyyy= "19"+value.substring(6,8);
        mm= value.substring(8,10);
        dd= value.substring(10,12);
        result= yyyy + "-" + mm+ "-" + dd;
    } else if (len == 18) {
        yyyy= value.substring(6,10);
        mm= value.substring(10,12);
        dd= value.substring(12,14);
        result= yyyy + "-" + mm+ "-" + dd;
    }     
    return result;
}

// 根据身份证号获得性别
// @param value 身份证号
// @return "1"：男；"0"：女
function getSexByIdCard(value) {
    var result= "1";
    if (!value) return result;
    var len= value.length;
    if (len == 15) {
        if ("13579".indexOf(value.substring(14,15))!=-1) {
            result= "1";
        }else{
            result= "0";
        }
    } else if (len == 18) {
        if ("13579".indexOf(id.substring(16,17)) > -1) {
            result= "1";
        }else{
            result= "0";
        }
    }     
    return result;
}

// 把15位身份证号转换为18身份证号
// @param value 15位身份证号
// @return 18位身份证号,如果不是有效的15位身份证号返回value
function convertIdCard(value) {
    var result= value;
    if (value.length==15 && "ok"==checkIdCard(value)) {
        if (value.substring(6,8)>20) {
            result= value.substring(0,6)+"19" + value.substring(6,15);
        } else {
            result= value.substring(0,6)+"20" + value.substring(6,15);
        }
        result= result + getIdCardVerifyBit(value);
    }
    return result;
}

//-----------------------------------------------------------------------------
// 以下方法为对数据控件进行有效性检查使用的，入参为text对象
//-----------------------------------------------------------------------------
// 判断一个输入框的数值是否为有效的日期，如果不是给出提示，支持的日期格式为yyyy-mm-dd、
// yyyy年mm月dd日。
// @param thisObj 输入控件
// @return 是有效的日期返回true否则返回false
function validateDate(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isDate(value);
    if (!result) {
        alert("日期格式无效，请输入正确的日期，\n例如：2004-01-01！");
        thisObj.focus();
    }
    return result;
}    

// 判断一个输入框的数值是否为有效的时间，如果不是给出提示，支持的时间格式为mm:hh:ss、hh时mm分ss秒。
// @param thisObj 输入控件
// @return 是有效的时间返回true否则返回false
function validateTime(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isTime(value);
    if (!result) {
        alert("时间格式无效，请输入正确的时间，\n例如：21:05:59！");
        thisObj.focus();
    }
    return result;
}  

// 判断一个输入框的数值是否为有效的日期时间，如果不是给出提示，
// 支持的格式为yyyy-mm-dd hh:mm:ss、yyyy年mm月dd日hh时mm分ss秒 。
// @param thisObj 输入控件
// @return 是有效的日期时间返回true否则返回false
function validateTimestamp(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isTimestamp(value);
    if (!result) {
        alert("日期时间格式无效，请输入正确的日期时间，\n例如：2004-01-01 21:05:59！");
        thisObj.focus();
    }
    return result;
}  

// 判断一个输入框的数值是否为有效的日期时间，如果不是给出提示，
// 支持的格式为yyyy-mm-dd hh:mm:ss、yyyy年mm月dd日hh时mm分 。
// @param thisObj 输入控件
// @return 是有效的日期时间返回true否则返回false
function validateTimestampWithoutSecond(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isTimestampNoSec(value);
    if (!result) {
        alert("日期时间格式无效，请输入正确的日期时间，\n例如：2004-01-01 21:05！");
        thisObj.focus();
    }
    return result;
}  

// 判断一个输入框的数值是否为有效的日期时间，如果不是给出提示，
// 支持的格式为yyyy-mm-dd hh:mm:ss、yyyy年mm月dd日hh时mm分 。
// @param thisObj 输入控件
// @return 是有效的日期时间返回true否则返回false
function validateTimestampNoSec(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isTimestampNoSec(value);
    if (!result) {
        alert("日期时间格式无效，请输入正确的日期时间，\n例如：2004-01-01 21:05！");
        thisObj.focus();
    }
    return result;
}  


// 判断一个输入框的数值是否可以转换为一个无符号整数，是返回true否则返回false，
// @param thisObj 输入控件
// @return 可以转换为一个无符号整数返回true否则返回false
function validateUnsigned(thisObj) {
     //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isUnsigned(value);
    if (!result) {
        alert("数字格式无效，请输入正确的正整数，\n例如：1234！");
        thisObj.focus();
    }
    return result;
}


// 判断一个输入框的数值是否可以转换为一个无符号整数且不是零，是返回true否则返回false，
// @param thisObj 输入控件
// @return 可以转换为一个无符号整数返回true否则返回false
function validateUnsignedWithZero(thisObj) {
     //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result = true;
    if(!isUnsigned(value)||value=="0")
       result = false;
    if (!result) {
        alert("数字格式无效，请输入正确的不包括零的正整数，\n例如：1234！");
        thisObj.focus();
    }
    return result;
}


// 判断一个输入框的数值是否可以转换为一个整数，是返回true否则返回false，
// @param thisObj 输入控件
// @return 可以转换为一个整数返回true否则返回false
function validateInteger(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isInteger(value);
    if (!result) {
        alert("数字格式无效，请输入正确的整数，\n例如：1234！");
        thisObj.focus();
    }
    return result;
}

// 判断一个输入框的数值是否可以转换为一个长整数，是返回true否则返回false，
// @param thisObj 输入控件
// @return 可以转换为一个整数返回true否则返回false
function validateLong(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isLong(value);
    if (!result) {
        alert("数字格式无效，请输入正确的长整数，\n例如：1234！");
        thisObj.focus();
    }
    return result;
}

// 判断一个输入框的数值是否可以转换为一个浮点数，是返回true否则返回false，
// @param thisObj 输入控件
// @return 可以转换为一个浮点返回true否则返回false
function validateFloat(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isFloat(value);
    if (!result) {
        alert("数字格式无效，请输入正确的浮点数，\n例如：1234.01！");
        thisObj.focus();
    }
    return result;
}
// 判断一个输入框的数值是否可以转换为一个浮点数并且该浮点数必须小于等于100，是返回true否则返回false，
// @param thisObj 输入控件
// @return 可以转换为一个浮点并且该浮点数小于等于100返回true否则返回false
function validateXsFloat(thisObj){
	if(!thisObj) return false;
	var value=thisObj.value;
	if(!value||value=="") return true;
	var result=isFloat(value);
	if(!result){
		alert("数字格式无效，请输入正确的数据，\n例如：1234.01！");
		thisObj.focus();
		return false;
	}else if(value>=100){
		alert("请输入小于100的数据");
		thisObj.focus();		
		return false;
	}
	return true;
}
// 判断一个输入框的数值是否是有效的年份，是返回true否则返回false，
// @param thisObj 输入控件
// @return 可以转换为一个年份返回true否则返回false
function validateYear(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= isYear(value);
    if (!result) {
        alert("请输入有效的年份，范围从1901到3000，\n例如：2004！");
        thisObj.focus();
    }
    return result;
}

// 判断一个输入框的数值是否是有效的身份证号，是返回true否则返回false，
// @param thisObj 输入控件
// @return 有效返回true否则返回false
function validateIdCard(thisObj) {
    //首先判断参数有效性
    if (!thisObj) return false;
    var value= thisObj.value;
    if (!value || value=="") return true;
    var result= checkIdCard(value);
    alert(getBirthdayByIdCard(value));
    alert(getSexByIdCard(value));
    alert(convertIdCard(value));
        
        
    if ("ok" != result) {
        alert("身份证号码无效，" + result + "。\n请输入有效的身份证号！");
        thisObj.focus();
        return false;
    }
    return true;
}

/**
 * 把一个数字四舍五入后变为具有指定小数位数的数字。
 * @param value 需要处理的数字
 * @param scale 小数位数
 * @return 经过处理的数字
 */
function roundFloat(value, scale) {
    var temp= 1000000;
    if (arguments.length==2) {
        if (scale==1) {
            temp= Math.round(value*10);
            return temp/10;
        } else if (scale==2) {
            temp= Math.round(value*100);
            return temp/100;
        } else if (scale==3) {
            temp= Math.round(value*1000);
            return temp/1000;
        } else if (scale==4) {
            temp= Math.round(value*10000);
            return temp/10000;
        } else if (scale==5) {
            temp= Math.round(value*100000);
            return temp/100000;
        } else {
            temp= Math.round(value*1000000);
            return temp/1000000;
        }    
    }
    temp= Math.round(value*1000000);
    return temp/1000000;
}

// 使一个form的所有元素变为可修改或不可修改。
// @param form form对象
// @param disable 是否变为不可修改，true变为不可修改否则变为可修改
function disableForm(form, disable) {
    var disabled= true;
    if (arguments.length == 2) { disabled= disable; }
    if (!form) { return; }
    for (var j=0;j<form.length;j++) {
        if (form.elements[j].type=="text") {
            form.elements[j].readOnly= disabled;
            if (form.elements[j].onclick) form.elements[j].onclick= "";
        } else if (form.elements[j].type=="textarea") {
            form.elements[j].readOnly= disabled;
        } else if (form.elements[j].type=="password") {
           form.elements[j].readOnly= disabled;
        } else if (form.elements[j].type=="file") {
            form.elements[j].disabled= disabled;
        } else if (form.elements[j].type=="radio") {
            form.elements[j].disabled= disabled;
        } else if (form.elements[j].type=="checkbox") {
            form.elements[j].disabled= disabled;
        } else if (form.elements[j].type=="select-one") {
            form.elements[j].disabled= disabled;
        } else if (form.elements[j].type=="select-multiple") {
            form.elements[j].disabled= disabled;
        } else if (form.elements[j].type=="button") {
            form.elements[j].disabled= disabled;
        } else if (form.elements[j].type=="reset") {
            form.elements[j].disabled= disabled;
        } else if (form.elements[j].type=="submit") {
            form.elements[j].disabled= disabled;
        } else {
            form.elements[j].disabled= disabled;
        }
    }
}

// 使一个form中指定的元素变为可修改或不可修改。
// @param form form对象
// @param elements 需要变为可修改或不可修改的对象名称数组
// @param disable 是否变为不可修改，true变为不可修改否则变为可修改
function disableFormElements(form, elements, disable) {
    var disabled= true;
    if (arguments.length == 3) { disabled= disable; }
    if (!form) { return; }
    for (var i=0;i<elements.length;i++) {
        for (var j=0;j<form.length;j++) {
        	if (elements[i]!=form.elements[j].name) { continue; }
            if (form.elements[j].type=="text") {
                form.elements[j].readOnly= disabled;
                if (form.elements[j].onclick) form.elements[j].onclick="";
            } else if (form.elements[j].type=="textarea") {
                form.elements[j].readOnly= disabled;
            } else if (form.elements[j].type=="password") {
               form.elements[j].readOnly= disabled;
            } else if (form.elements[j].type=="file") {
                form.elements[j].disabled= disabled;
            } else if (form.elements[j].type=="radio") {
                form.elements[j].disabled= disabled;
            } else if (form.elements[j].type=="checkbox") {
                form.elements[j].disabled= disabled;
            } else if (form.elements[j].type=="select-one") {
                form.elements[j].disabled= disabled;
            } else if (form.elements[j].type=="select-multiple") {
                form.elements[j].disabled= disabled;
            } else if (form.elements[j].type=="button") {
                form.elements[j].disabled= disabled;
            } else if (form.elements[j].type=="reset") {
                form.elements[j].disabled= disabled;
            } else if (form.elements[j].type=="submit") {
                form.elements[j].disabled= disabled;
            } else {
                form.elements[j].disabled= disabled;
            }
        }
    }
}

//------------------------------------------------------------------------
// spinner控件使用的方法
//------------------------------------------------------------------------
/**
 * 第一次按下鼠标左键时执行
 * @param thisObj 输入控件
 * @param thisEvent 事件
 * @param forWidget 被控制的控件ID
 * @param action 增加还是减少
 * @param minValue 允许的最小数值
 * @param maxValue 允许的最大数值
 * @param step 每次增加的数值
 * @return 继续处理返回true否则返回false
 */
function spinnerMousedown(thisObj, thisEvent, forWidget, action, minValue, maxValue, stepValue) 
{
    if (thisEvent.button!=1) { return true; } 
    if (thisObj.interval) {
        window.clearInterval(thisObj.interval);
    }
    var intervalAction= "spinnerProcess('" + forWidget + "','";
    if (action) { intervalAction= intervalAction + action; }
    intervalAction= intervalAction + "','";
    if (minValue) { intervalAction= intervalAction + minValue; }
    intervalAction= intervalAction + "','";
    if (maxValue) { intervalAction= intervalAction + maxValue; }
    intervalAction= intervalAction + "','";
    if (stepValue) { intervalAction= intervalAction + stepValue; }
    intervalAction= intervalAction + "')";
    spinnerProcess(forWidget, action, minValue, maxValue, stepValue);
    thisObj.interval= window.setInterval(intervalAction, 200);
    return false;
}

/** 
 * 鼠标弹起时终止定时器
 * @param thisObj 输入控件
 * @param thisEvent 事件
 * @return 继续处理返回true否则返回false
 */
function spinnerMouseup(thisObj, thisEvent) {
    if (thisEvent.button!=1) { return true; } 
    if(thisObj.interval) {
        window.clearInterval(thisObj.interval);
        thisObj.intval= null;
    }
    return false;
}

/**
 * 定时执行增加或减少的操作
 * @param thisObj 输入控件
 * @param thisEvent 事件
 * @param action 增加还是减少
 * @param minValue 允许的最小数值
 * @param maxValue 允许的最大数值
 * @param stepValue 每次增加的数值
 */
function spinnerProcess(forWidget, action, minValue, maxValue, stepValue) {
    var widget= null;
    if (document.all) { 
        widget= document.all[forWidget]; 
    } else if (document.getElementById) {
        widget= document.getElementById(forWidget);
    }
    if (!widget) return true;
    var currentValue= parseFloat(widget.value);
    stepValue= parseFloat(stepValue);
    if (isNaN(stepValue)) stepValue= 1;
    minValue= parseFloat(minValue);
    maxValue= parseFloat(maxValue);
	if (isNaN(currentValue)) {
	    if (action=="up") {
	        if (isNaN(minValue)) { widget.value= 0; } else { widget.value= minValue; }
	    } else { 
	     	if (isNaN(maxValue)) { widget.value= 0; } else { widget.value= maxValue; }
	    }
	} else {
		if (action=="up") { 
		    if ((!isNaN(maxValue))&&(currentValue>=maxValue)) {
		        if (!isNaN(minValue)) { currentValue= minValue; }
		    } else {
		        currentValue= currentValue + stepValue;
		    }    
	    } else {
	    	if ((!isNaN(minValue))&&(currentValue<=minValue)) {
	    	    if (!isNaN(maxValue)) { currentValue= maxValue; }
		    } else {
	            currentValue= currentValue - stepValue;
	        }
	    }
	    var temp= Math.round(currentValue*1000000);
	    if ((temp%1000000)!=0) { currentValue= temp/1000000; }
	    widget.value= currentValue;
	}
    return true;
}

// Title: 验证表单 2005-2-1
// 规则表达式或者函数，用于验证输入数据的格式
var re_dt = /^(\d{4})\-(\d{1,2})\-(\d{1,2})$/;//日期格式,yyyy-mm-dd或yyyy-m-d
var re_tm = /^(\d{1,2})\:(\d{1,2})\:(\d{1,2})$/;//time格式
var a_formats = {
	'alpha'   : /^[a-zA-Z\.\-]*$/,
	'alphanum': /^\w+$/,
	'unsigned': /^\d+$/,
	'integer' : /^[\+\-]?\d*$/,
	'real'    : /^[\+\-]?\d*\.?\d*$/,
	'email'   : /^[\w-\.]+\@[\w\.-]+\.[a-z]{2,4}$/,
	'phone'   : /^[\d\.\s\-]+$/,
	'date'    : function (s_date) {
		// 检查格式
		if (!re_dt.test(s_date))
			return false;
		// 检查允许的范围	
		if (RegExp.$3 > 31 || RegExp.$2 > 12)
			return false;
		// 检查每月的天数
		var dt_test = new Date(RegExp.$1, Number(RegExp.$2-1), RegExp.$3);
		if (dt_test.getMonth() != Number(RegExp.$2-1))
			return false;
		return true;
	},
	'time'    : function validate_time(s_time) {
		// 检查格式
		if (!re_tm.test(s_time))
			return false;
		// 检查允许的范围	
		if (RegExp.$1 > 23 || RegExp.$2 > 59 || RegExp.$3 > 59)
			return false;
		return true;
	},'TimestampNoSec': function(value){
		//首先判断参数有效性
	    if (arguments.length != 1) return false;
	    if (!value) return false;
	    if (value == "") return false;
	    //首先根据格式yyyy-mm-dd hh:mm进行判断
	    var reg_dts= /^(\d{4})\-(\d{1,2})\-(\d{1,2})\ (\d{1,2})\:(\d{1,2})$/;
	    var reg_dtl= /^(\d{4})\年(\d{1,2})\月(\d{1,2})\日(\d{1,2})\时(\d{1,2})\分$/;
	    //检验日期格式
	    if (!reg_dts.test(value) && !reg_dtl.test(value)) return false;
	    //检验年范围
		if (RegExp.$1 > 3000 || RegExp.$1 <1901) return false;
		//检验月范围
		if (RegExp.$2 >12 || RegExp.$2 < 1) return false;
		//检验日范围
		if (RegExp.$3 > 31 || RegExp.$3 <1) return false;
	    //检验一个月中的天数
		var dt_test = new Date(RegExp.$1, Number(RegExp.$2-1), RegExp.$3);
		if (dt_test.getMonth() != Number(RegExp.$2-1)) return false;
		//检验时间各个段的范围
		if (RegExp.$4 > 23 || RegExp.$5 > 59) return false;
		return true;
	}
};
var a_messages = [
	'必须传递form这个参数',
	'没有用来验证的 "%form%" 表单属性数组',
	'文档中没有"%form%" 这个表单',
	'不完整的 "%n%" 表单字段描述，缺少 "l" 属性',
	'在表单 "%form%" 中没有找到 字段 "%n%" ',
	'不能找到 (id="%t%")的标签tag',
	'不能验证匹配. 字段 "%m%" 找不到',
	'"%l%" 字段不能为空',
	'"%l%" 的值必须至少 "%min%" 个字符(1个汉字算2个字符)',
	'"%l%" 的值最多不超过 "%max%" 个字符(1个汉字算2个字符)',
	'"%v%" 不是 "%l%"的有效值',
	'"%l%" 必须包含 "%ml%"'
];




//验证构造函数validator
function validator(s_form, a_fields, o_cfg) {
	this.f_error = validator_error;
	this.f_alert = o_cfg && o_cfg.alert
		? function(s_msg) { alert(s_msg); return false; }
		: function() { return false };
		
	//检查要求的参数
	if (!s_form)	
		return this.f_alert(this.f_error(0));
	this.s_form = s_form;
	
	if (!a_fields || typeof(a_fields) != 'object')
		return this.f_alert(this.f_error(1));
	this.a_fields = a_fields;

	
	this.exec = validator_exec;
}

//验证执行方法
function validator_exec() {
	var o_form = document.forms[this.s_form];
	if (!o_form)	
		return this.f_alert(this.f_error(2));
		
	b_dom = document.body && document.body.innerHTML;
	
	
	//检查form字段描述结构的完整性
	for (var n_key in this.a_fields) {
		// 检查输入描述接口
		this.a_fields[n_key]['n'] = n_key;
		if (!this.a_fields[n_key]['l'])
			return this.f_alert(this.f_error(3, this.a_fields[n_key]));
		o_input = o_form.elements[n_key];
		if (!o_input)
			return this.f_alert(this.f_error(4, this.a_fields[n_key]));
		this.a_fields[n_key].o_input = o_input;
	}

	//重置高亮( highlight)的标签label字段
	if (b_dom)
		for (var n_key in this.a_fields) 
			if (this.a_fields[n_key]['t']) {
				var s_labeltag = this.a_fields[n_key]['t'], e_labeltag = get_element(s_labeltag);
				if (!e_labeltag)
					return this.f_alert(this.f_error(5, this.a_fields[n_key]));
				this.a_fields[n_key].o_tag = e_labeltag;
				
				//标签label正常时的样式
				e_labeltag.className = 'dataForm_fieldLabel';
			}

	// 根据输入字段的类型，收集输入的值
	for (var n_key in this.a_fields) {
		o_input = this.a_fields[n_key].o_input;
		this.a_fields[n_key]['v']="";//判断前，将该字段的值"认为"是空
		if (o_input.value || o_input.checked) // text, password, hidden, checkbox
			this.a_fields[n_key]['v'] = o_input.value;
		else if (o_input.options) // select
			this.a_fields[n_key]['v'] = o_input.selectedIndex > -1
				? o_input.options[o_input.selectedIndex].value
				: null;
		else if (o_input.length > 0) // radiobuton
			for (var n_index = 0; n_index < o_input.length; n_index++)
				if (o_input[n_index].checked) {
					this.a_fields[n_key]['v'] = o_input[n_index].value;
					break;
				}
	}
	
	// 检查输入的错误
	var n_errors_count = 0,
		n_another, o_format_check;
	for (var n_key in this.a_fields) {
		o_format_check = this.a_fields[n_key]['f'] && a_formats[this.a_fields[n_key]['f']]
			? a_formats[this.a_fields[n_key]['f']]:this.a_fields[n_key]['f'];
			//: null;

		// reset前面的错误
		this.a_fields[n_key].n_error = null;

		// 检查必填字段
		if (this.a_fields[n_key]['r'] && !this.a_fields[n_key]['v']) {
			this.a_fields[n_key].n_error = 1;
			n_errors_count++;
		}
		// 检查字段长度,一个中文字符对应2个字节,modify by Macro on 2005-4-9
		//else if (this.a_fields[n_key]['min'] && String(this.a_fields[n_key]['v']).length < this.a_fields[n_key]['min']) {
		else if (this.a_fields[n_key]['min'] && String(this.a_fields[n_key]['v']).replace(/[^\x00-\xff]/g,"ma").length < this.a_fields[n_key]['min']) {
			this.a_fields[n_key].n_error = 2;
			n_errors_count++;
		}
		else if (this.a_fields[n_key]['max'] && String(this.a_fields[n_key]['v']).replace(/[^\x00-\xff]/g,"ch").length > this.a_fields[n_key]['max']) {
			this.a_fields[n_key].n_error = 3;
			n_errors_count++;
		}
		// 检查格式format
		else if (this.a_fields[n_key]['v'] && this.a_fields[n_key]['f'] && (
			(typeof(o_format_check) == 'function'
			&& !o_format_check(this.a_fields[n_key]['v']))
			|| (typeof(o_format_check) != 'function'
			&& !o_format_check.test(this.a_fields[n_key]['v'])))
			) {
			this.a_fields[n_key].n_error = 4;
			n_errors_count++;
		}
		// 检查是否匹配match字段
		else if (this.a_fields[n_key]['m']) {
			for (var n_key2 in this.a_fields)
				if (n_key2 == this.a_fields[n_key]['m']) {
					n_another = n_key2;
					break;
				}
			if (n_another == null)
				return this.f_alert(this.f_error(6, this.a_fields[n_key]));
			if (this.a_fields[n_another]['v'] != this.a_fields[n_key]['v']) {
				this.a_fields[n_key]['ml'] = this.a_fields[n_another]['l'];
				this.a_fields[n_key].n_error = 5;
				n_errors_count++;
			}
		}
		
		
	}


	//收集错误信息和高亮(highlight)错误字段的标签label
	var s_alert_message = '',
		e_first_error;

	if (n_errors_count) {
		for (var n_key in this.a_fields) {
			var n_error_type = this.a_fields[n_key].n_error,
				s_message = '';
				
			if (n_error_type)
				s_message = this.f_error(n_error_type + 6, this.a_fields[n_key]);

			if (s_message) {
				if (!e_first_error)
					e_first_error = o_form.elements[n_key];
				s_alert_message += s_message + "\n";
				// 高亮时label标签的样式
				if (b_dom && this.a_fields[n_key].o_tag)
				{
        //this.a_fields[n_key].o_tag.oldClassName= this.a_fields[n_key].o_tag.className;'dataForm_fieldLabel_HighLight';
					this.a_fields[n_key].o_tag.className = 'dataForm_fieldLabel_highLight';
					}
			}
		}
		alert(s_alert_message);
		// 设置焦点focus到第一个错误字段
		if (e_first_error.focus)
			e_first_error.focus();
		// 取消提交表单
		return false;
	}
	
	return true;
}

//验证错误函数
function validator_error(n_index) {
	var errMsg = a_messages[n_index], n_i = 1, s_key;
	for (; n_i < arguments.length; n_i ++)
		for (s_key in arguments[n_i])
			errMsg = errMsg.replace('%' + s_key + '%', arguments[n_i][s_key]);
	errMsg = errMsg.replace('%form%', this.s_form);
	return errMsg;
}

//get element
function get_element (s_id) {
	return (document.all ? document.all[s_id] : (document.getElementById ? document.getElementById(s_id) : null));
}
function getlenb(tstr)
{
j=0
for (i=0;i<tstr.length;i++)
{
    if(tstr.charCodeAt(i)>255)
        j++;
    j++;

}
return j;
}

function validateemail(obj){
  if(obj.value!=""){
	  if(!checkemail(obj.value)){
	    alert("邮箱格式不正确");
	    obj.focus();
	  }
  }
}


function checkint(tstr)
{
re=/[^0-9]/;
rp=tstr.search(re); 
return rp;
}


function checkhz(tstr)
{
for (i=0;i<tstr.lengt;i++)
    if( tstr.charCodeAt(i)>255 )
        {
            return 1;
            break;
        }
//alert(String.fromCharCode(258))
return 0;

}

function checkstr(tstr)
{
//re=/[^a-zA-Z0-9_]/;
re=/\W/;
rp=tstr.search(re); 
return rp;

}
function checkhtml(tstr)
{
//re=/[^a-zA-Z0-9_]/;
re=/<(.*)>.*<\/\1>/;
rp=tstr.search(re); 
return rp;

}

function checkblank(tstr)
{
//re=/[^a-zA-Z0-9_]/;
re=/\s/;
rp=tstr.search(re); 
return rp;

}

function checkemail(tstr)
{
re1=/([\w\-\.])+[@]{1}([\w\-])+(\.[\w\-])+/;
rp1=tstr.search(re1); 

re2=/[^a-zA-Z0-9_\.\-\@]/;
rp2=tstr.search(re2);
//alert(rp1)
if (rp1==-1||rp2!=-1)
    return false;    
else
    return true;
}

function checksqlstr(tstr)
{
re1=/[\^\s',\s\$]/;

rp1=tstr.search(re1);
//rp2=tstr.search(re2);
if (rp1!=-1)
    return false
else 
    return true;
    
}

//屏蔽 Alt+ 方向键 ←
//屏蔽 Alt+ 方向键 →
//屏蔽退格删除键
//屏蔽 F5 刷新键
//屏蔽Ctrl + R
//屏蔽 Ctrl+n
//屏蔽 shift+F10
//屏蔽 shift 加鼠标左键新开一网页
//屏蔽Alt+F4
function diskey()
{
	alert(window.event.altKey+window.event.keyCode);
	
	if ((window.event.altKey)&&
	((window.event.keyCode==37)|| //屏蔽 Alt+ 方向键 ←
	(window.event.keyCode==39))){ //屏蔽 Alt+ 方向键 →
	alert("无效操作！");
	event.returnValue=false;
	}
	
	if ((event.keyCode==8) || //屏蔽退格删除键
	(event.keyCode==116)|| //屏蔽 F5 刷新键
	(event.ctrlKey && event.keyCode==82)){ //Ctrl + R
	event.keyCode=0;
	event.returnValue=false;
	}
	if ((event.ctrlKey)&&(event.keyCode==78)) //屏蔽 Ctrl+n
	event.returnValue=false;
	if ((event.shiftKey)&&(event.keyCode==121)) //屏蔽 shift+F10
	event.returnValue=false;
	if (window.event.srcElement.tagName == "A" && window.event.shiftKey) 
	window.event.returnValue = false; //屏蔽 shift 加鼠标左键新开一网页
	if ((window.event.altKey)&&(window.event.keyCode==115)){ //屏蔽Alt+F4
	window.showModelessDialog("about:blank","","dialogWidth:1px;dialogheight:1px");
	return false;}
}