<!--
//<meta http-equiv="content-type" content="text/html;charset=GB2312">
//<Script Language='JavaScript'>
var gDateDelimiter="-";		//日期分隔符
var gCrLf="\r\n";			//回车换行(CRLF)

//函数：gHalf2Full(str)
//半角字符转换成全角字符;
//输入参数str为string；返回值也为string。
function gHalf2Full(str)
{
	var sHalf="abcdefghijklmnopqrstuvwxyz"+
		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"+
		"0123456789"+
		",./;'[]~!#$%*()-+={}|:\"<>?";
	var sFull="ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ"+
		"ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ"+
		"０１２３４５６７８９"+
		"，。／；‘［］～！＃￥％＊（）－＋＝｛｝｜：“《》？";
	for(var res="",i=0;i<str.length;i++)
	{
		var ch=str.charAt(i);
		var j=sHalf.indexOf(ch);

		res+=((j>=0)? sFull.charAt(j):ch);
	}

	return res;
}

//--------------------daysofmonth(non,year)函数----------------------------
//返回每月天数
function gDaysOfMonth(mon,year)
{
	if ((mon==4)||(mon==6)||(mon==9)||(mon==11)) return 30;
	else if (mon!=2) return 31;
	if ((year % 4 == 0)&&(year % 100 !=0)||(year % 400==0)) return 29;
	else return 28;
}

//--------------------gLtrim(str)函数----------------------------
//滤掉字符串左空格；
function gLtrim(str)
{
	str=str+"";
	for(var i=0;(i<str.length)&&(str.charAt(i)==" ");i++);
	return str.substring(i,str.length);
}
//--------------------gRtrim(instr)函数----------------------------
//滤掉字符串右空格；
function gRtrim(str)
{
	str=str+"";
	for(var i=str.length-1;(i>=0)&&(str.charAt(i)==" ");i--);
	return str.substring(0,i+1);
}
//--------------------gAlltrim(str)函数----------------------------
//滤掉字符串左右空格；
function gAlltrim(str)
{
	return gRtrim(gLtrim(str));
}

//函数：gConvertSpecialChar(str)
//输入参数：
//	str——string，源字符串
//返回值：
//	string，结果字符串
//说明：
//	字符串转义，将字符串中的字符“"”和“\”转换成“\"”和“\\”，
//	以便字符串输出到浏览器端的JavaScript字符串变量。
function gConvertSpecialChar(str)
{
	for(var s="",i=0;i<str.length;i++)
	{
		var ch=str.charAt(i);
		if(ch=="\"") s+="\\\"";
		else if(ch=="\\") s+="\\\\";
		else s+=ch;
	}

	return s;
}

//********函数：gGetStrByte(str)********
//输入参数：
//	str——string，源字符串
//返回值：
//	int，字节数
//说明：
//	取字符串str字节长度。
function gGetStrByte(str)
{
	for(var sc=escape(str),n=0,i=0;i<sc.length;n++)
	{
		if(sc.charAt(i++)!="%") continue;	//所有空格,标点,重音符号和非ASCII字符都用%xx编码
		if(sc.charAt(i)=="u")				//字符的值大于255的用%uxxxx格式
		{
			i+=5;
			n++;
		}
		else i+=2;
	}
	return n;
}

//********函数：gGetRadioValue(radioBtnArray)********
//输入参数：
//	radioBtn——radio对象
//返回值：
//	string，radio对象的value值
//说明：
//	取radio对象当前选择的value值，如果radio对象没有选中选项，返回""。
function gGetRadioValue(radioBtn)
{
	if(radioBtn.length==null) return (radioBtn.checked? radioBtn.value:"");
	for(var i=0;i<radioBtn.length;i++) if(radioBtn[i].checked) return radioBtn[i].value;
	return "";
}

//********函数：gSetRadioValue(radioBtnArray,valstr)********
//输入参数：
//	radioBtnArray——radio对象
//	valstr——string，要选择的radio对象选项的value值
//返回值：
//	boolean，成功=true，失败=false
//说明：
//	将radio对象当前选中的选项设为value值为valstr的选项。
//	如果radio对象没有此选项，则设为缺省选项，返回false；否则返回true。
function gSetRadioValue(radioBtn,valstr)
{
	if(radioBtn.length==null)
	{
		radioBtn.checked=true;
		return (radioBtn.value==valstr);
	}
	for(var i=0,j=0;i<radioBtn.length;i++)
	{
		if(radioBtn[i].value==valstr)
		{
			radioBtn[i].checked=true;
			return true;
		}
		if(radioBtn[i].defaultChecked) j=i;
	}
	radioBtn[j].checked=true;
	return false;


	for(var i=0,j=0;(i<radioBtn.length)&&(radioBtn[i].value!=valstr);i++)
		if(radioBtn[i].defaultChecked) j=i;
	if(i>=radioBtn.length)
	{
		radioBtn[j].checked=true;
		return false;
	}
	radioBtn[i].checked=true;
	return true;
}

//********函数：gEnableRadio(radioBtnArray,bEna)********
//输入参数：
//	radioBtnArray——radio对象
//	bEna——boolean，使能=true，禁止=false
//返回值：
//	无
//说明：
//	设radio对象的使能状态。
function gEnableRadio(radioBtnArray,bEna)
{
	for(var i=0;i<radioBtnArray.length;i++) radioBtnArray[i].disabled=(!bEna);
}

//********函数：gSetRadioBkColor(docobj,rdobj,bkclr)********
//输入参数：
//	docobj——document对象
//	rdobj——radio对象
//	bkclr——string，背景色
//返回值：
//	无
//说明：
//	设RadioButton组的背景色，如果每个RadioButton都有LABEL标记，也设置其背景色。
//	每个LABEL标记的ID属性须为"lbl_"+RadioButton的NAME属性+RadioButton的序号,
//	序号从1开始。
function gSetRadioBkColor(docobj,rdobj,bkclr)
{
	for(var i=0;i<rdobj.length;i++)
	{
		rdobj[i].style.backgroundColor=bkclr;
		var lblobj=docobj.all("lbl_"+rdobj[i].name+(i+1));
		if(lblobj!=null) lblobj.style.backgroundColor=bkclr;
	}
}

//********函数：gSetCheckBoxBkColor(docobj,chkobj,bkclr)********
//输入参数：
//	docobj——document对象
//	chkobj——CheckBox对象
//	bkclr——string，背景色
//返回值：
//	无
//说明：
//	设CheckBox的背景色，如果CheckBox有LABEL标记，也设置其背景色。
//	LABEL标记的ID属性须为"lbl_"+CheckBox的NAME属性。
function gSetCheckBoxBkColor(docobj,chkobj,bkclr)
{
	chkobj.style.backgroundColor=bkclr;
	var lblobj=docobj.all("lbl_"+chkobj.name);
	if(lblobj!=null) lblobj.style.backgroundColor=bkclr;
}

//********函数：gAddSelect(docobj,selobj,valstr,txtstr,id,bselected)********
//输入参数：
//	docobj——document对象
//	selobj——select框对象
//	valstr——string，选项value值
//	txtstr——string，选项text值
//	id——int，要插入的位置，即选项的index值
//	bselected——boolean，选项是否被选择
//返回值：
//	无
//说明：
//	向select输入框中插入单个选项。
function gAddSelect(docobj,selobj,valstr,txtstr,id,bselected)
{
	newitem=docobj.createElement("OPTION");
	newitem.value=valstr;
	newitem.text=txtstr;
	selobj.add(newitem,id);
	newitem.selected=bselected;
}

//********函数：gSetSelect(selObj,selTxt)********
//输入参数：
//	selObj——select框对象
//	selTxt——string，选项value值
//返回值：
//	int，选中选项的索引值
//说明：
//	将select对象的当前选中选项设为value值为selTxt的选项。
//	如果select对象没有此选项，则设为第一个选项。返回选中选项的索引值。
function gSetSelect(selObj,selTxt)
{
	for(var i=0;(i<selObj.length)&&(selObj.item(i).value!=selTxt);i++);
	if(i>=selObj.length) i=0;
	selObj.selectedIndex=i;
	return i;
}

//********函数：gSetSelectByText(selObj,selTxt)********
//输入参数：
//	selObj——select框对象
//	selTxt——string，选项text值
//返回值：
//	int，选中选项的索引值
//说明：
//	将select对象的当前选中选项设为text值为selTxt的选项。
//	如果select对象没有此选项，则设为第一个选项。返回选中选项的索引值。
function gSetSelectByText(selObj,selTxt)
{
	for(var i=0;(i<selObj.length)&&(selObj.options(i).text!=selTxt);i++);
	if(i>=selObj.length) i=0;
	selObj.selectedIndex=i;
	return i;
}

//********函数：gGetSelectText(selObj)********
//输入参数：
//	selObj——select框对象
//返回值：
//	string，文本值
//说明：
//	取select对象当前选中选项的文本值(不是value值)。
function gGetSelectText(selObj)
{
	if(selObj.selectedIndex<0) return "";
	return selObj.item(selObj.selectedIndex).innerText;
}

//********函数：gLoadSelect(docobj,selobj,astr[,val_equ_txt])********
//输入参数：
//	docobj——document对象
//	selobj——select框对象
//	asrc——string数组，选项定义，格式："选项1VALUE`选项1显示TEXT","选项2VALUE`选项2显示TEXT",...
//	val_equ_txt——boolean，选项的VALUE属性是否等于显示TEXT，不带此参数，为不等于
//返回值：
//	无
//说明：
//	添加一组选项到select输入框的最后。
function gLoadSelect(docobj,selobj,asrc,val_equ_txt)
{
	for(var b=((val_equ_txt!=null)? val_equ_txt:false),j=selobj.length,i=0;i<asrc.length;i++,j++)
	{
		var tmp=asrc[i].split("`");
		gAddSelect(docobj,selobj,(b? tmp[1]:tmp[0]),tmp[1],j,false);
	}
}

//********函数：gIsReservedKeycode(keycode)********
//输入参数：
//	keycode——键码
//返回值：
//	boolean，是保留键=true，非保留键=false
//说明：
//	返回是否保留键。
function gIsReservedKeycode(keycode)
{
	switch(keycode)
	{
		case 39:		//char: '
		case 94:		//char: ^
		case 96:		//char: `
		case 124:		//char: |
		return true;
	}
	return false;
}

//********函数：gIsValidEmail(str)********
//输入参数：
//	str——string，源字符串
//返回值：
//	boolean，true=合法email或空串，false=非法
//说明：
//	返回email地址<str>是否合法，允许空串。
function gIsValidEmail(str)
{
	var p_end=str.length-1, p_at=str.indexOf('@'), p_dot=str.lastIndexOf('.');
	return (p_end==-1 || (p_at>0 && p_dot>(p_at+1) && p_dot<p_end));
}

//********函数：gIsValidIP(str)********
//输入参数：
//	str——string，源字符串
//返回值：
//	boolean，true=合法IP或空串，false=非法
//说明：
//	返回IP地址<str>是否合法，允许空串。
function gIsValidIP(str)
{
	var s=gAlltrim(str);
	if(s.length<1) return true;
	var a=s.split(".");
	if(a.length!=4) return false;
	for(var i=0;i<4;i++)
	{
		if(!gIsInteger(a[i])) return false;
		a[i]=parseInt(a[i]);
		if(a[i]<0||a[i]>255) return false;
	}
	return (a[0]>0);
}

//********函数：gIsPositiveInteger(sVal)********
//输入参数：
//	sVal——string，源字符串
//返回值：
//	boolean，true=合法正整数或空串，false=非法
//说明：
//	返回正整数<sVal>是否合法，允许空串。
function gIsPositiveInteger(sVal)
{
	for(var s=gAlltrim(sVal),imax=s.length,i=0;i<imax;i++)
		if("0123456789".indexOf(s.charAt(i))<0) return false;
	return true;
}

//********函数：gIsInteger(sVal)********
//输入参数：
//	sVal——string，源字符串
//返回值：
//	boolean，true=合法整数或空串，false=非法
//说明：
//	返回整数<sVal>是否合法，允许空串。
function gIsInteger(sVal)
{
	for(var s=gAlltrim(sVal),imax=s.length,i=0;i<imax;i++)
		if("-0123456789".indexOf(s.charAt(i))<0) return false;
	return (s.indexOf('-')<=0);
}

//********函数：gIsPositiveFloat(sVal)********
//输入参数：
//	sVal——string，源字符串
//返回值：
//	boolean，true=合法正浮点数或空串，false=非法
//说明：
//	返回正浮点数<sVal>是否合法，允许空串。
function gIsPositiveFloat(sVal)
{
	for(var s=gAlltrim(sVal),imax=s.length,i=0;i<imax;i++)
		if(".0123456789".indexOf(s.charAt(i))<0) return false;
	return true;
}

//********函数：gIsFloat(sVal)********
//输入参数：
//	sVal——string，源字符串
//返回值：
//	boolean，true=合法浮点数或空串，false=非法
//说明：
//	返回浮点数<sVal>是否合法，允许空串。
function gIsFloat(sVal)
{
	for(var s=gAlltrim(sVal),imax=s.length,i=0;i<imax;i++)
		if("-.0123456789".indexOf(s.charAt(i))<0) return false;
	return (s.indexOf('-')<=0);
}

//********函数：gReplace(src,sFor,sBy)********
//输入参数：
//	src——string，源字符串
//	sFor——string，要查找的子串
//	sBy——string，要替换的子串
//返回值：
//	结果字符串
//说明：
//	将字符串src中的所有子串sFor替换成子串sBy
function gReplace(src,sFor,sBy)
{
	if(sFor==""||sBy=="") return src;
	for(var l=sFor.length,s="",p0=0,p;(p=src.indexOf(sFor,p0))>=0;s+=src.substring(p0,p)+sBy,p0=p+l);
	return (s+src.substring(p0));
}

//********函数：gReplaceAt(src,iAt,iLen,sBy)********
//输入参数：
//	src——string，源字符串
//	iAt——int，要查找的子串位置
//	iLen——int，要查找的子串长度
//	sBy——string，要替换的子串
//返回值：
//	结果字符串
//说明：
//	将字符串src中的位置为iAt长度为iLen的子串替换成子串sBy
function gReplaceAt(src,iAt,iLen,sBy)
{
	if(iAt>=src.length) return src;
	return (src.substring(0,iAt)+sBy+src.substring(iAt+iLen));
}

//********函数：gCutStrTail(src,nchars)********
//输入参数：
//	src——string，源字符串
//	nchars——int，字符数
//返回值：
//	结果字符串
//说明：
//	截断字符串src尾nchars个字符。如果src为空串或nchars大于src长度，返回""。
function gCutStrTail(src,nchars)
{
	if(src==null||src==""||src.length<=nchars) return "";
	return (src.substring(0,src.length-nchars));
}

//********函数：gGetArrayIndex(asrc,val[,bNoCase])********
//输入参数：
//	asrc——Array，目标数组
//	val——要查找的值，若bNoCase=true，类型为字符串
//	bNoCase——boolean，不区分大小写=true，区分大小写=false
//返回值：
//	int，找到=索引值，失败=-1。
//说明：
//	查询val在数组asrc中的索引，如果不带参数bNoCase，则区分大小写。
function gGetArrayIndex(asrc,val,bNoCase)
{
	var up=((bNoCase==null)? false:bNoCase);
	if(up) val=val.toUpperCase();
	for(var i=0;i<asrc.length;i++)
	{
		var tmp=(up? asrc[i].toUpperCase():asrc[i]);
		if(tmp==val) return i;
	}
	return -1;
}

//********函数：gCode2Name(atable,scode)********
//输入参数：
//	atable——Array，代码数组，格式为"代码`名称"
//	scode——string，要查找的代码值
//返回值：
//	string，找到=代码名称，失败=""。
//说明：
//	查询代码scode的名称，代码表为atable。
function gCode2Name(atable,scode)
{
	for(var i=0;i<atable.length;i++)
	{
		var atmp=atable[i].split("`");
		if(atmp[0]==scode) return atmp[1];
	}
	return "";
}

//********函数：gName2Code(atable,sname)********
//输入参数：
//	atable——Array，代码数组，格式为"代码`名称"
//	sname——string，要查找的名称值
//返回值：
//	string，找到=代码，失败=""。
//说明：
//	查询名称sname的代码，代码表为atable。
function gName2Code(atable,sname)
{
	for(var i=0;i<atable.length;i++)
	{
		var atmp=atable[i].split("`");
		if(atmp[1]==sname) return atmp[0];
	}
	return "";
}

//********函数：gCode2Index(atable,scode)********
//输入参数：
//	atable——Array，代码数组，格式为"代码`名称"
//	scode——string，要查找的代码值
//返回值：
//	int，找到=代码数组索引，失败=-1。
//说明：
//	查询代码scode的代码数组索引，代码表为atable。
function gCode2Index(atable,scode)
{
	for(var i=0;i<atable.length;i++)
	{
		var atmp=atable[i].split("`");
		if(atmp[0]==scode) return i;
	}
	return -1;
}

//********函数：gCode2Array(atable,scode)********
//输入参数：
//	atable——Array，代码串数组，串格式为"代码`名称"
//	scode——string，要查找的代码值
//返回值：
//	找到=代码串转换数组，失败=null
//说明：
//	查询代码scode的代码串，转换成数组返回，代码表为atable。
function gCode2Array(atable,scode)
{
	for(var i=0;i<atable.length;i++)
	{
		var atmp=atable[i].split("`");
		if(atmp[0]==scode) return atmp;
	}
	return null;
}

//********函数：gFormatNumberText(fval,npoint)********
//输入参数：
//	fval——float，要格式化的浮点数
//	npoint——int，小数位数
//返回值：
//	string，结果字符串
//说明：
//	格式化浮点数fval为npoint位小数，并进行四舍五入，返回其字符串值。
function gFormatNumberText(fval,npoint)
{
	var x=Math.pow(10,npoint);
	var s=(Math.round(fval*x)/x+"");
	var p=s.indexOf("."), n=npoint;
	if(p<0)
	{
		p=s.length;
		s+=".";
	}
	if(n<=0) return s.substring(0,p);
	n-=s.length-p-1;
	for(var i=0;i<n;i++) s+="0";
	return s;
}

//********函数：gGetPercentText(iNum,iLength)********
//输入参数：
//	iNum——float，要转换的浮点数
//	iLength——int，小数位数
//返回值：
//	string，结果字符串
//说明：
//	将浮点数iNum转换为iLength位小数的百分数，并进行四舍五入，返回其字符串值。
function gGetPercentText(iNum,iLength)
{
	return gFormatNumberText(iNum*100,iLength);
}

//********函数：gGetDateTimeStr(iChoice,oDate)********
//输入参数：
//	iChoice——int，转换标志
//	oDate——Date对象，日期时间
//返回值：
//	string，日期时间串。
//说明：
//	将Date对象转换为日期时间串。iChoice定义如下：
//	0=日期，格式："yyyy/mm/dd"。
//	1=时间，格式："hh:mm:ss"。
//	2=日期时间，格式："yyyy/mm/dd hh:mm:ss"。
//	100=日期，格式："yyyy年mm月dd日"。
//	101=时间，格式："hh时mm分ss秒"。
//	102=日期时间，格式："yyyy年mm月dd日 hh时mm分ss秒"。
function gGetDateTimeStr(iChoice,oDate)
{
	var yy=oDate.getFullYear(), mm=oDate.getMonth()+1, dd=oDate.getDate();
	var hh=oDate.getHours(), nn=oDate.getMinutes(), ss=oDate.getSeconds();
	if(mm<10) mm="0"+mm;
	if(dd<10) dd="0"+dd;
	if(hh<10) hh="0"+hh;
	if(nn<10) nn="0"+nn;
	if(ss<10) ss="0"+ss;

	if(iChoice==0) return (yy+gDateDelimiter+mm+gDateDelimiter+dd);
	if(iChoice==1) return (hh+":"+nn+":"+ss);
	if(iChoice==2) return (yy+gDateDelimiter+mm+gDateDelimiter+dd+" "+hh+":"+nn+":"+ss);

	if(iChoice==100) return (yy+"年"+mm+"月"+dd+"日");
	if(iChoice==101) return (hh+"时"+nn+"分"+ss+"秒");
	if(iChoice==102) return (yy+"年"+mm+"月"+dd+"日"+" "+hh+"时"+nn+"分"+ss+"秒");

	return "";
}

//********函数：gDateDiff(dateStr1,dateStr2)********
//输入参数：
//	dateStr1——结束日期串，格式："yyyy/mm/dd"或"yyyy-mm-dd"
//	dateStr2——开始日期串，格式："yyyy/mm/dd"或"yyyy-mm-dd"
//返回值：
//	int，天数。
//说明：
//	返回日期<dateStr1>-<dateStr2>的天数差。
function gDateDiff(dateStr1,dateStr2)
{
	return parseInt((Date.parse(gReplace(dateStr1,"-","/"))-Date.parse(gReplace(dateStr2,"-","/")))/86400000);
}

//********函数：gDateAdd(dateStr,addYear,addMonth,addDate)********
//输入参数：
//	dateStr——日期串，格式："yyyy/mm/dd"或"yyyy-mm-dd"
//	addYear——int，要增减的年数
//	addMonth——int，要增减的月数
//	addDate——int，要增减的日数
//返回值：
//	string，日期串。
//说明：
//	返回在日期<dateStr>上增减的日期。
function gDateAdd(dateStr,addYear,addMonth,addDate)
{
	var dt=new Date(Date.parse(gReplace(dateStr,"-","/")));
	dt.setFullYear(dt.getFullYear()+addYear);
	dt.setMonth(dt.getMonth()+addMonth);
	dt.setDate(dt.getDate()+addDate);
	return gGetDateTimeStr(0,dt);
}

//********函数：gNextShortYear(dateStr)********
//输入参数：
//	dateStr——日期串，格式："yyyy/mm/dd"或"yyyy-mm-dd"
//返回值：
//	string，日期串。
//说明：
//	返回在日期<dateStr>上加1年减1天的日期。
function gNextShortYear(dateStr)
{
	return gDateAdd(dateStr,1,0,-1);
}

//********函数：gNextYear(dateStr)********
//输入参数：
//	dateStr——日期串，格式："yyyy/mm/dd"或"yyyy-mm-dd"
//返回值：
//	string，日期串。
//说明：
//	返回在日期<dateStr>上加1年的日期。
function gNextYear(dateStr)
{
	return gDateAdd(dateStr,1,0,0);
}

//********函数：gGetToday()********
//输入参数：
//	无
//返回值：
//	string，当天日期串。
//说明：
//	取当天日期串，格式："yyyy/mm/dd"。
function gGetToday()
{
	var dt=new Date();
	return gGetDateTimeStr(0,dt);
}

//********函数：gCanSetFocus(elobj)********
//输入参数：
//	elobj——输入项对象
//返回值：
//	int，-1=输入项不可设焦点，1=文本类输入项(TEXT,TEXTAREA,PASSWORD,FILE)，
//		2=按钮类输入项(BUTTON,SUBMIT,RESET,IMAGE)，0=其他类型输入项
//说明：
//	取输入项是否可以设输入焦点，如果可以的话，还返回输入项类型。
function gCanSetFocus(elobj)
{
	var stagname=elobj.tagName.toUpperCase();
	if(stagname=="FIELDSET") return -1;
	var sType=elobj.type.toUpperCase();
	if((sType=="HIDDEN")||(elobj.disabled)) return -1;
	for(var o=elobj;o.tagName.toUpperCase()!="BODY"&&o.style.display.toUpperCase()!="NONE";o=o.parentElement);
	if(o.tagName.toUpperCase()!="BODY") return -1;
	var rtn=((sType=="TEXT"||sType=="TEXTAREA"||sType=="PASSWORD"||sType=="FILE")? 1:
			((sType=="BUTTON"||sType=="SUBMIT"||sType=="RESET"||sType=="IMAGE")? 2:0));
	if(rtn==1&&elobj.readOnly) return -1;
	return rtn;
}

//********函数：gCutTableTail(tblobj,rows2del)********
//输入参数：
//	tblobj——<TABLE>表对象
//	rows2del——要删除的行数
//返回值：
//	int，<TABLE>表新行数
//说明：
//	从<TABLE>表尾部删除指定数量的行。
function gCutTableTail(tblobj,rows2del)
{
	for(var i=0,j=tblobj.rows.length-1;i<rows2del&&j>=0;i++,j--)
	{
		if(j>0) tblobj.deleteRow(j);
		else tblobj.deleteRow();
	}
	return tblobj.rows.length;
}

//********函数：gPrintFrame(frame_to_print,show_print_dialog,on_finish_function)********
//输入参数：
//	frame_to_print——frame对象，要打印的frame
//	show_print_dialog——boolean，是否显示打印对话框：true=是，false=不
//	on_finish_function——函数对象，gPrintFrame返回前调用的用户函数，可以为null
//返回值：
//	无
//说明：
//	打印frame中显示的页面。
function gPrintFrame(frame_to_print,show_print_dialog,on_finish_function)
{
	var ctx=new Object;
	ctx.focused=document.activeElement;
	ctx.prompt=show_print_dialog;
	ctx.onfinish=on_finish_function;
	ctx.doPrint=function()
	{
		this.onerror=window.onerror;
		window.onerror=this["finalize"];
		document.all("idWBPrint").ExecWB(6,(this.prompt? 1:2));
		this.finalize();
	}
	ctx.finalize=function()
	{
		window.onerror=this.onerror;
		document.all("idWBPrint").outerHTML="";
		if(this.onfinish) this.onfinish();
		this.focused.focus();
		window.printCtx=null;
		return true;
	}
	document.body.insertAdjacentHTML("beforeEnd",
		"<object id='idWBPrint' width=0 height=0 classid='clsid:8856F961-340A-11D0-A96B-00C04FD705A2'></object>");
	frame_to_print.focus();
	window.printCtx=ctx;
	setTimeout("window.printCtx.doPrint()",0);
}

///////////////////////////////////////
//给表格项加onkeypressed event catch the key Return and Esc/
//Frame and Form are which your Form and your elements on
//in your program you can only have one form add this function
function gAddKeyCatcher(Frame,Form)
{
	if(Form.elements.length==0) return true;
	gKeyFrame=Frame;
	gKeyForm=Form;
	for(var i=0;i<Form.elements.length;i++){
		Form.elements[i].onkeypress=gKeyCatcher;
	}
	gKeyCatcher(true);
}

//捕获键盘事件
function gKeyCatcher(bFirst)
{
	var thisKey;
	var srcElement;
	if(bFirst){
		thisKey=13;
		srcElement=gKeyForm.elements[gKeyForm.elements.length-1];
	}else{
		thisKey = gKeyFrame.window.event.keyCode;
		srcElement = gKeyFrame.window.event.srcElement;
		if(gIsReservedKeycode(thisKey)) return false;
		if(thisKey==27){
			gKeyFrame.window.event.srcElement.blur();
			gKeyFrame.window.event.srcElement.focus();
			return true;
		}

		if(gKeyFrame.window.event.srcElement.type.toUpperCase()=='TEXTAREA')
			return true;
	}

	if(thisKey!=13) return true;

	for(var i=0,iThis=-1;;)
	{
		if(gKeyForm.elements[i]==srcElement)
		{
			if(iThis==i) return true;
			iThis = i;
		}

		if(i==(gKeyForm.elements.length-1)) i=0;
		else i++;

		if(iThis==-1) continue;

		var toItem=gKeyForm.elements[i], itp=gCanSetFocus(toItem);
		if(itp<0||itp==2) continue;

		if(itp==1) toItem.select();
		toItem.focus();
		return false;
	}
}

function gIsDisplay(pelement){//to decide the display property of an item style
	if(pelement.tagName=="INPUT"&&pelement.type=="hidden") return false;
	while(pelement.tagName!="BODY"&&pelement.style.display!="none")
		pelement=pelement.parentElement;
	if(pelement.tagName=="BODY") return true;
	else return false;
}

//==============================================================================
function nocontextmenu(){//windows
	event.cancelBubble = true
	event.returnValue = false;
	return false;
}

function norightclick(e){
	if (window.Event){
		if (e.which == 2 || e.which == 3)
			   return false;
		 }else  if (event.button == 2 || event.button == 3){
			event.cancelBubble = true
			   event.returnValue = false;
			   return false;
	}
}
function _load(){
	try{
		form1.code.focus();
	}catch(e){}
}
function getDaysOfMonth(year,month){
	//return (new Date(year+"/"+(month+1)+"/0").getDate());
	var days = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
	  if (year%4==0 || (year%100==0 && year%400 == 0))//闰年
		days[1] = 29;
	  return days[month-1];
}
function insertNBSP(n){//插入n个&nbsp
  var ret="";
  for(var i=0;i<n;i++)
	ret+="&nbsp;";
  return ret;
}
-->
