var w0=screen.width; //窗口初始宽度
var w1_max=250;//左侧菜单宽度-max
var w1_min=0;//左侧菜单宽度-min
var w1=w1_min;//左侧菜单宽度
var w3_max=350; //右侧选择工具栏宽度-max
var w3_min=0; //右侧选择工具栏宽度-min
var w3=w3_min;
var w4_max=350;//右侧库存选择宽度-max
var w4_min=0; //右侧库存选择宽度-min
var w4=w4_min;
var w2=screen.width-w1-w3-w4; //中间主工作区宽度

function haveDetailData(checkObj)
{ 	//校验有明细内容
	for(i=0;i<checkObj.length;i++)
	{
		if(checkObj[i].value!="")
		{
			return true;
		}
	}
	alert("请填入明细行！");
	return false;
}

function checkSmallInner(obj,alertWrite){
	if(obj.value==null || obj.value=="")
	{
		if(alertWrite)
		{
			alert("请填写完整数据！");
			obj.select();
		}
		return false;
	}
	else
		return true;
}

function c1(obj){ //校验是否为空，且若为空，给出提示
	return checkSmallInner(obj,true);
}
function c2(obj,alertWrite){ //校验是否为空，单不给提示
	return checkSmallInner(obj,false);
}

function switchLeftBar(){ //对左侧菜单的开关
if(w1==w1_min)
{
	top.left.style.display="";
	w1=w1_max;
	top.leftBarImg.src=top.leftBarImg.src.substring(0,top.leftBarImg.src.indexOf("bar"))+"bar2.gif";
}
else
{
	top.left.style.display="none";
	w1=w1_min;
	top.leftBarImg.src=top.leftBarImg.src.substring(0,top.leftBarImg.src.indexOf("bar"))+"bar1.gif";
}
w2=screen.width-w1-w3-w4;
top.left.style.width=w1;
top.main.style.width=w2;
}

function openWindow(theUrl)
{
	window.open(theUrl,"print","location=0,menubar=0,resizable=1,status=1,left=0,top=0,height=200,width=300");
}
function openWindow1(theUrl)
{
	window.open(theUrl,"print","location=0,menubar=1,resizable=1,status=1,left=0,top=0,height=200,width=300");
}
function openWindow(theUrl,theHeight,theWidth)
{
	window.open(theUrl,"print","location=0,menubar=0,resizable=1,scrollbars=yes,status=1,left=0,top=0,height="+theHeight+",width="+theWidth);
}
function openWindow1(theUrl,theHeight,theWidth)
{
	window.open(theUrl,"print","location=0,menubar=1,resizable=1,scrollbars=yes,status=1,left=0,top=0,height="+theHeight+",width="+theWidth);
}
function openWindow1(theUrl,name,theHeight,theWidth)
{
	window.open(theUrl,name,"location=0,menubar=1,resizable=1,scrollbars=yes,status=1,left=0,top=0,height="+theHeight+",width="+theWidth);
}
function openWindow2(theUrl,theHeight,theWidth,id)
{
	window.open(theUrl,"print"+id,"location=0,menubar=0,resizable=1,scrollbars=yes,status=1,left=0,top=0,height="+theHeight+",width="+theWidth);
}
function openWebViewWindow(theUrl)
{
	window.open(theUrl,"webwindow","location=0,menubar=0,resizable=1,scrollbars=yes,status=1,left=0,top=0,height=700,width=640");
}
function checkRepeatedInner(obj){//校验明细行中是否有重复出现取值
	maxRowNo_repeat=obj.length;
	for(i_repeat=0;i_repeat<maxRowNo_repeat;i_repeat++)
	{
		if(obj[i_repeat].value!="")
		{
			for(j_repeat=(i_repeat+1);j_repeat<maxRowNo_repeat;j_repeat++)
			{
				if(obj[i_repeat].value==obj[j_repeat].value)
				{
					alert("第"+(i_repeat+1)+"行和第"+(j_repeat+1)+"行相同！请修改！");
					obj[j_repeat].select();
					return false;
				}
				else
					continue;
			}
		}
		else
			continue;
	}
	return true;
}

function closeAllRight(){//关闭右侧的两个助选页
top.right.style.display="none";
top.right2.style.display="none";
if(parent.left.style.display=="none")
	parent.main.style.width=parseInt(screen.width);
else
	parent.main.style.width=parseInt(screen.width)-parseInt(parent.left.style.width);

}

function confirmDelete(theName,theUrl){//确认删除操作
	if(confirm("确定删除 "+theName+" ？"))
		location=theUrl;
}
function confirmOperation(theName,theUrl){//确认某操作
	if(confirm("确定"+theName+"？"))
		location=theUrl;
}
//禁止右键
function disableRightClick(e)
{
  /* 
  var message = "禁止点击右键！";
  if(!document.rightClickDisabled) // initialize
  {
    if(document.layers) 
    {
      document.captureEvents(Event.MOUSEDOWN);
      document.onmousedown = disableRightClick;
    }
    else document.oncontextmenu = disableRightClick;
    return document.rightClickDisabled = true;
  }
  if(document.layers || (document.getElementById && !document.all))
  {
    if (e.which==2||e.which==3)
    {
      alert(message);
      return false;
    }
  }
  else
  {
    alert(message);
    return false;
  }
  */
 
}
function selectAll(theSelectAllObj,theSelectNames) //全选，全不选 
{
	var theSelectNamesChecked=theSelectAllObj.checked;
	for(i=0;i<theSelectNames.length;i++)
	{
		theSelectNames[i].checked=theSelectNamesChecked;
	}
}
function checkAtLeastSelectOne(theSelectNames2,theSelectTitle) //校验表单中的theSelectNames是否至少有一项内容
{
	for(i=0;i<theSelectNames2.length;i++)
	{
		if(theSelectNames2[i].checked)
			return true;
	}
	alert("请至少选择一项 "+theSelectTitle+" !");
	return false;
}
function OnUploadFile(projectId, fileType)
{
  window.open("../project/projectmanage.jspx?command=viewAttachment&projectId="+projectId+"&attachmentType="+fileType,"upload","width=400,height=260,scrollbars=no,left="+(screen.width/2-200).toString()+",top="+(screen.height/2-130).toString()+"");
	
}
function OnUploadCertFile(projectId, fileType)
{
  window.open("upload.jsp?projectId="+projectId+"&attachmentType="+fileType,"upload","width=400,height=260,scrollbars=no,status=yes,left="+(screen.width/2-200).toString()+",top="+(screen.height/2-130).toString()+"");
	
}

function timestamp()
{
    var timestamp = Date.parse(new Date());
    return timestamp;
}
function OnUploadAttach()
{
  window.open("uploadattach.jsp","upload","width=400,height=260,scrollbars=no,left="+(screen.width/2-200).toString()+",top="+(screen.height/2-130).toString()+"");
	
}
function theFormHidden(theForm)
{ //将表单隐藏,表单的onSubmit事件调用时,放在最后,如:  onSubmit="return (validateForm(this) && checkHaveOneMoreDetail() && theFormHidden(this) );"
		theForm.style.display="none";
		theFormIsSubmiting.style.top=document.body.scrollTop+100;
		if(screen.width > 1024){
		   theFormIsSubmiting.style.width = 600;
		   theFormIsSubmiting.style.left= (document.body.clientWidth - 600)/2;

		}else{
		   theFormIsSubmiting.style.width = 400;
		   theFormIsSubmiting.style.left= (document.body.clientWidth - 400)/2;
		}


		theFormIsSubmiting.style.display="";
		return true;	

}

function viewHelp() //打开查看帮助的界面
{
window.open("../help/"+top.aboutMenu.dir.value+"/"+top.aboutMenu.menuid.value+".htm");
}
function viewHelp(theMenuId) //打开查看帮助的界面
{
window.open("../help/"+top.aboutMenu.dir.value+"/"+theMenuId+".htm");
}
function viewHelpIndex() //打开帮助的首页
{
window.open("../help/"+top.aboutMenu.dir.value+"/index.htm");
}


/*

-------------- 函数检索 --------------
trim函数:                         trim() lTrim() rTrim()
校验字符串是否为空:                 checkIsNotEmpty(str)
校验字符串是否为整型:               checkIsInteger(str)
校验整型最小值:                    checkIntegerMinValue(str,val)
校验整型最大值:                    checkIntegerMaxValue(str,val) 
校验整型是否为非负数:               isNotNegativeInteger(str)
校验字符串是否为浮点型:             checkIsDouble(str) 
校验浮点型最小值:                  checkDoubleMinValue(str,val)
校验浮点型最大值:                  checkDoubleMaxValue(str,val)
校验浮点型是否为非负数:             isNotNegativeDouble(str)
校验字符串是否为日期型:             checkIsValidDate(str)
校验两个日期的先后:                checkDateEarlier(strStart,strEnd)
校验字符串是否为email型:           checkEmail(str)

校验字符串是否为中文:               checkIsChinese(str)
计算字符串的长度，一个汉字两个字符:   realLength()
校验字符串是否符合自定义正则表达式:   checkMask(str,pat)
得到文件的后缀名:                   getFilePostfix(oFile)  
-------------- 函数检索 --------------
*/

/**
* added by LxcJie 2004.6.25
* 去除多余空格函数
* trim:去除两边空格 lTrim:去除左空格 rTrim: 去除右空格
* 用法：
*     var str = "  hello ";
*     str = str.trim();
*/
String.prototype.trim = function()
{
    return this.replace(/(^[\\s]*)|([\\s]*$)/g, "");
}
String.prototype.lTrim = function()
{
    return this.replace(/(^[\\s]*)/g, "");
}
String.prototype.rTrim = function()
{
    return this.replace(/([\\s]*$)/g, "");
}
/********************************** Empty **************************************/
/**
*校验字符串是否为空
*返回值：
*如果不为空，定义校验通过，返回true
*如果为空，校验不通过，返回false               参考提示信息：输入域不能为空！
*/
function checkIsNotEmpty(str)
{
    if(str.trim() == "")
        return false;
    else
        return true;
}//~~~

function checkIsEmpty(str)
{
    if(str.trim() == "")
        return true;
    else
        return false;
}
/*--------------------------------- Empty --------------------------------------*/
/********************************** Integer *************************************/
/**
*校验字符串是否为整型
*返回值：
*如果为空，定义校验通过，      返回true
*如果字串全部为数字，校验通过，返回true
*如果校验不通过，              返回false     参考提示信息：输入域必须为数字！
*/
function checkIsInteger(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(/^(\\-?)(\\d+)$/.test(str))
        return true;
    else
        return false;
}//~~~
/**
*校验整型最小值
*str：要校验的串。  val：比较的值
*
*返回值：
*如果为空，定义校验通过，                返回true
*如果满足条件，大于等于给定值，校验通过，返回true
*如果小于给定值，                        返回false              参考提示信息：输入域不能小于给定值！
*/
function checkIntegerMinValue(str,val)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(typeof(val) != "string")
        val = val + "";
    if(checkIsInteger(str) == true)
    {
        if(parseInt(str,10)>=parseInt(val,10))
            return true;
        else
            return false;
    }
    else
        return false;
}//~~~
/**
*校验整型最大值
*str：要校验的串。  val：比较的值
*
*返回值：
*如果为空，定义校验通过，                返回true
*如果满足条件，小于等于给定值，校验通过，返回true
*如果大于给定值，                        返回false       参考提示信息：输入值不能大于给定值！
*/
function checkIntegerMaxValue(str,val)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(typeof(val) != "string")
        val = val + "";
    if(checkIsInteger(str) == true)
    {
        if(parseInt(str,10)<=parseInt(val,10))
            return true;
        else
            return false;
    }
    else
        return false;
}//~~~
/**
*校验整型是否为非负数
*str：要校验的串。
*
*返回值：
*如果为空，定义校验通过，返回true
*如果非负数，            返回true
*如果是负数，            返回false               参考提示信息：输入值不能是负数！
*/
function isNotNegativeInteger(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(checkIsInteger(str) == true)
    {
        if(parseInt(str,10) < 0)
            return false;
        else
            return true;
    }
    else
        return false;
}//~~~
/*--------------------------------- Integer --------------------------------------*/
/********************************** Double ****************************************/
/**
*校验字符串是否为浮点型
*返回值：
*如果为空，定义校验通过，      返回true
*如果字串为浮点型，校验通过，  返回true
*如果校验不通过，              返回false     参考提示信息：输入域不是合法的浮点数！
*/
function checkIsDouble(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    //如果是整数，则校验整数的有效性
    if(str.indexOf(".") == -1)
    {
        if(checkIsInteger(str) == true)
            return true;
        else
            return false;
    }
    else
    {
        if(/^(\\-?)(\\d+)(.{1})(\\d+)$/g.test(str))
            return true;
        else
            return false;
    }
}//~~~
/**
*校验浮点型最小值
*str：要校验的串。  val：比较的值
*
*返回值：
*如果为空，定义校验通过，                返回true
*如果满足条件，大于等于给定值，校验通过，返回true
*如果小于给定值，                        返回false              参考提示信息：输入域不能小于给定值！
*/
function checkDoubleMinValue(str,val)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(typeof(val) != "string")
        val = val + "";
    if(checkIsDouble(str) == true)
    {
        if(parseFloat(str)>=parseFloat(val))
            return true;
        else
            return false;
    }
    else
        return false;
}//~~~
/**
*校验浮点型最大值
*str：要校验的串。  val：比较的值
*
*返回值：
*如果为空，定义校验通过，                返回true
*如果满足条件，小于等于给定值，校验通过，返回true
*如果大于给定值，                        返回false       参考提示信息：输入值不能大于给定值！
*/
function checkDoubleMaxValue(str,val)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(typeof(val) != "string")
        val = val + "";
    if(checkIsDouble(str) == true)
    {
        if(parseFloat(str)<=parseFloat(val))
            return true;
        else
            return false;
    }
    else
        return false;
}//~~~
/**
*校验浮点型是否为非负数
*str：要校验的串。
*
*返回值：
*如果为空，定义校验通过，返回true
*如果非负数，            返回true
*如果是负数，            返回false               参考提示信息：输入值不能是负数！
*/
function isNotNegativeDouble(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if(checkIsDouble(str) == true)
    {
        if(parseFloat(str) < 0)
            return false;
        else
            return true;
    }
    else
        return false;
}//~~~
/*--------------------------------- Double ---------------------------------------*/
/********************************** date ******************************************/
/**
*校验字符串是否为日期型
*返回值：
*如果为空，定义校验通过，           返回true
*如果字串为日期型，校验通过，       返回true
*如果日期不合法，                   返回false    参考提示信息：输入域的时间不合法！（yyyy-MM-dd）
*/
function checkIsValidDate(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    var pattern = /^((\\d{4})|(\\d{2}))-(\\d{1,2})-(\\d{1,2})$/g;
    if(!pattern.test(str))
        return false;
    var arrDate = str.split("-");
    if(parseInt(arrDate[0],10) < 100)
        arrDate[0] = 2000 + parseInt(arrDate[0],10) + "";
    var date =  new Date(arrDate[0],(parseInt(arrDate[1],10) -1)+"",arrDate[2]);
    if(date.getYear() == arrDate[0]
       && date.getMonth() == (parseInt(arrDate[1],10) -1)+""
       && date.getDate() == arrDate[2])
        return true;
    else
        return false;
}//~~~
/**
*校验两个日期的先后
*返回值：
*如果其中有一个日期为空，校验通过,          返回true
*如果起始日期早于等于终止日期，校验通过，   返回true
*如果起始日期晚于终止日期，                 返回false    参考提示信息： 起始日期不能晚于结束日期。
*/
function checkDateEarlier(strStart,strEnd)
{
    if(checkIsValidDate(strStart) == false || checkIsValidDate(strEnd) == false)
        return false;
    //如果有一个输入为空，则通过检验
    if (( strStart == "" ) || ( strEnd == "" ))
        return true;
    var arr1 = strStart.split("-");
    var arr2 = strEnd.split("-");
    var date1 = new Date(arr1[0],parseInt(arr1[1].replace(/^0/,""),10) - 1,arr1[2]);
    var date2 = new Date(arr2[0],parseInt(arr2[1].replace(/^0/,""),10) - 1,arr2[2]);
    if(arr1[1].length == 1)
        arr1[1] = "0" + arr1[1];
    if(arr1[2].length == 1)
        arr1[2] = "0" + arr1[2];
    if(arr2[1].length == 1)
        arr2[1] = "0" + arr2[1];
    if(arr2[2].length == 1)
        arr2[2]="0" + arr2[2];
    var d1 = arr1[0] + arr1[1] + arr1[2];
    var d2 = arr2[0] + arr2[1] + arr2[2];
    if(parseInt(d1,10) > parseInt(d2,10))
       return false;
    else
       return true;
}//~~~
/*--------------------------------- date -----------------------------------------*/
/********************************** email *****************************************/
/**
*校验字符串是否为email型
*返回值：
*如果为空，定义校验通过，           返回true
*如果字串为email型，校验通过，      返回true
*如果email不合法，                  返回false    参考提示信息：Email的格式不正確！
*/
function checkEmail(str)
{
    //如果为空，则通过校验
    if(str == "")
        return true;
    if (str.charAt(0) == "." || str.charAt(0) == "@" || str.indexOf("@", 0) == -1
        || str.indexOf(".", 0) == -1 || str.lastIndexOf("@") == str.length-1 || str.lastIndexOf(".") == str.length-1)
        return false;
    else
        return true;
}//~~~
/*--------------------------------- email ----------------------------------------*/
/********************************** chinese ***************************************/
/**
*校验字符串是否为中文
*返回值：
*如果为空，定义校验通过，           返回true
*如果字串为中文，校验通过，         返回true
*如果字串为非中文，             返回false    参考提示信息：必须为中文！
*/
function checkIsChinese(str)
{
    //如果值为空，通过校验
    if (str == "")
        return true;
    var pattern = /^([\\u4E00-\\u9FA5]|[\\uFE30-\\uFFA0])*$/gi;
    if (pattern.test(str))
        return true;
    else
        return false;
}//~~~
/**
* 计算字符串的长度，一个汉字两个字符
*/
String.prototype.realLength = function()
{
  return this.replace(/[^\\x00-\\xff]/g,"**").length;
}
/*--------------------------------- chinese --------------------------------------*/
/********************************** mask ***************************************/
/**
*校验字符串是否符合自定义正则表达式
*str 要校验的字串  pat 自定义的正则表达式
*返回值：
*如果为空，定义校验通过，           返回true
*如果字串符合，校验通过，           返回true
*如果字串不符合，                   返回false    参考提示信息：必须满足***模式
*/
function checkMask(str,pat)
{
    //如果值为空，通过校验
    if (str == "")
        return true;
    var pattern = new RegExp(pat,"gi")
    if (pattern.test(str))
        return true;
    else
        return false;
}//~~~
/*--------------------------------- mask --------------------------------------*/
/********************************** file ***************************************/
/**
* added by LxcJie 2004.6.25
* 得到文件的后缀名
* oFile为file控件对象
*/
function getFilePostfix(oFile)
{
    if(oFile == null)
        return null;
    var pattern = /(.*)\\.(.*)$/gi;
    if(typeof(oFile) == "object")
    {
        if(oFile.value == null || oFile.value == "")
            return null;
        var arr = pattern.exec(oFile.value);
        return RegExp.$2;
    }
    else if(typeof(oFile) == "string")
    {
        var arr = pattern.exec(oFile);
        return RegExp.$2;
    }
    else
        return null;
}//~~~

function formatNumber1(num,exponent) {
  if (exponent<1) return num;
  var str = num.toString();
  if (str.indexOf(".")!=-1) {
    if (str.split(".")[1].length>=exponent) {
      return str;
    } else {
      return formatNumber(str+"0",exponent);
    }
  } else {
    return formatNumber(str+".0",exponent);
  }

}
function formatNumber(value,num)   //四舍五入
{
 var a_int=parseInt(value*Math.pow(10,(num+1)));//乘以10的num+1次方
 if (a_int==0)
  return "0.00";
 var a_str=a_int.toString();//转成字符串
 
 if (a_str.substring(0,1)!="-")//正数
 {
  var b_str=a_str.substring(a_str.length-1,a_str.length);//取最后一位
  var b_int=parseInt(b_str);
  if (b_int>=5)
   a_int=a_int+10;
 }
 else//负数
 {
  var b_str=a_str.substring(a_str.length-1,a_str.length);
  var b_int=parseInt(b_str);
  if (b_int>=5)
   a_int=a_int-10;
 }
 a_str=a_int.toString();
 var leftlength=a_str.length-(num+1);//小数点左侧取的位数
 var rightlength=(num+1);//小数点右侧取的位数
 var leftstr = a_str.substring(0,leftlength);//小数点左侧的数
 var rightstr = a_str.substring(a_str.length-rightlength,a_str.length);
 rightstr = rightstr.substring(0,num);//小数点右侧的数
 //如果右侧最后是0，把0去掉
 if(rightstr != "" && rightstr != null)
 {
	 nozero_i = -1;
	 for(i=rightstr.length-1; i>=0; i--)
	 {  
		//alert(rightstr[i]);
		if(rightstr.charAt(i) != '0')
		{
		  	nozero_i = i;
			break;
		}
	 }
	 if(nozero_i == -1)//右侧都是0
	   rightstr = "";
	 else
	   rightstr = rightstr.substring(0,nozero_i+1);
	   
 }
 var c_str=leftstr+"."+rightstr;//重新组合字符串
 if(rightstr == "")
   c_str = leftstr;
 
 
 if (value.toString().substring(0,3)=="-0.")
  c_str="-0."+rightstr;
 if(value.toString().substring(0,2)=="0.")
  c_str="0."+rightstr;
 
 return c_str;
}
function convertCurrency(currencyDigits) {
	// Constants:
	var MAXIMUM_NUMBER = 99999999999.99;
	// Predefine the radix characters and currency symbols for output:
	var CN_ZERO = "零";
	var CN_ONE = "壹";
	var CN_TWO = "贰";
	var CN_THREE = "叁";
	var CN_FOUR = "肆";
	var CN_FIVE = "伍";
	var CN_SIX = "陆";
	var CN_SEVEN = "柒";
	var CN_EIGHT = "捌";
	var CN_NINE = "玖";
	var CN_TEN = "拾";
	var CN_HUNDRED = "佰";
	var CN_THOUSAND = "仟";
	var CN_TEN_THOUSAND = "万";
	var CN_HUNDRED_MILLION = "亿";
	var CN_SYMBOL = "人民币";
	var CN_DOLLAR = "元";
	var CN_TEN_CENT = "角";
	var CN_CENT = "分";
	var CN_INTEGER = "整";

	// Variables:
	var integral; // Represent integral part of digit number.
	var decimal; // Represent decimal part of digit number.
	var outputCharacters; // The output result.
	var parts;
	var digits, radices, bigRadices, decimals;
	var zeroCount;
	var i, p, d;
	var quotient, modulus;
	
	// Validate input string:
	currencyDigits = currencyDigits.toString();
	if (currencyDigits == "") {
	alert("Empty input!");
	return "";
	}
	if (currencyDigits.match(/[^,.\d]/) != null) {
	alert("Invalid characters in the input string!");
	return "";
	}
	//if ((currencyDigits).match(/^((\d{1,3}(,\d{3})*(.((\d{3},)*\d{1,3}))?)|(\d+(.\d+)?))$/) == null) {
	//alert("Illegal format of digit number!");
	//return "";
	//}
	
	// Normalize the format of input digits:
	currencyDigits = currencyDigits.replace(/,/g, ""); // Remove comma delimiters.
	currencyDigits = currencyDigits.replace(/^0+/, ""); // Trim zeros at the beginning.
	// Assert the number is not greater than the maximum number.
	if (Number(currencyDigits) > MAXIMUM_NUMBER) {
	alert("Too large a number to convert!");
	return "";
	}

	// Process the coversion from currency digits to characters:
	// Separate integral and decimal parts before processing coversion:
	parts = currencyDigits.split(".");
	if (parts.length > 1) {
	integral = parts[0];
	decimal = parts[1];
	// Cut down redundant decimal digits that are after the second.
	decimal = decimal.substr(0, 2);
	}
	else {
	integral = parts[0];
	decimal = "";
	}
	// Prepare the characters corresponding to the digits:
	digits = new Array(CN_ZERO, CN_ONE, CN_TWO, CN_THREE, CN_FOUR, CN_FIVE, CN_SIX, CN_SEVEN, CN_EIGHT, CN_NINE);
	radices = new Array("", CN_TEN, CN_HUNDRED, CN_THOUSAND);
	bigRadices = new Array("", CN_TEN_THOUSAND, CN_HUNDRED_MILLION);
	decimals = new Array(CN_TEN_CENT, CN_CENT);
	// Start processing:
	outputCharacters = "";
	// Process integral part if it is larger than 0:
	if (Number(integral) > 0) {
	zeroCount = 0;
	for (i = 0; i < integral.length; i++) {
	p = integral.length - i - 1;
	d = integral.substr(i, 1);
	quotient = p / 4;
	modulus = p % 4;
	if (d == "0") {
	zeroCount++;
	}
	else {
	if (zeroCount > 0)
	{
	outputCharacters += digits[0];
	}
	zeroCount = 0;
	outputCharacters += digits[Number(d)] + radices[modulus];
	}
	if (modulus == 0 && zeroCount < 4) {
	outputCharacters += bigRadices[quotient];
	}
	}
	outputCharacters += CN_DOLLAR;
	}
	// Process decimal part if there is:
	if (decimal != "") {
	for (i = 0; i < decimal.length; i++) {
	d = decimal.substr(i, 1);
	if (d != "0") {
	outputCharacters += digits[Number(d)] + decimals[i];
	}
	}
	}
	// Confirm and return the final output string:
	if (outputCharacters == "") {
	outputCharacters = CN_ZERO + CN_DOLLAR;
	}
	if (decimal == "") {
	outputCharacters += CN_INTEGER;
	}
	outputCharacters = CN_SYMBOL + outputCharacters;
	return outputCharacters;
}
//alert(formatNumber(41.235324,2));
var hkey_root,hkey_path,hkey_key
hkey_root="HKEY_CURRENT_USER"
hkey_path="\\Software\\Microsoft\\Internet Explorer\\PageSetup\\"
//设置网页打印的页眉页脚为空
function pagesetup_null(){
  try{
	var RegWsh = new ActiveXObject("WScript.Shell")
	hkey_key="header" 
	RegWsh.RegWrite(hkey_root+hkey_path+hkey_key,"")
	hkey_key="footer"
	RegWsh.RegWrite(hkey_root+hkey_path+hkey_key,"")
  }catch(e){}
}
//设置网页打印的页眉页脚为默认值
function pagesetup_default(){
  try{
	var RegWsh = new ActiveXObject("WScript.Shell")
	hkey_key="header" 
	RegWsh.RegWrite(hkey_root+hkey_path+hkey_key,"&w&b页码，&p/&P")
	hkey_key="footer"
	RegWsh.RegWrite(hkey_root+hkey_path+hkey_key,"&u&b&d")
  }catch(e){}
}


-->