function SetCwinHeight(obj){
	var name=obj;
  	if (document.getElementById){
    		if (name && !window.opera){
      			if (name.contentDocument && name.contentDocument.body.offsetHeight)
        			name.height = name.contentDocument.body.offsetHeight;
      			else if(name.Document && name.Document.body.scrollHeight)
        			name.height = name.Document.body.scrollHeight;
    		}
  	}
}

function ShowWindow(eP){
	var	dF	=	document.all.ModelWindow;
	var	wF	=	window.frames.ModelWindow;
	
 //读取嵌套页面是否载入成功！
  if(null == wF.g_fCalLoaded || false == wF.g_fCalLoaded){
    alert("不能打开模式窗口\r\n请重载页面！");
	return;
  }
  
  //把父窗体中需回写数据的对象赋给子页面中的变量
  wF.g_input = eP;
  
 //设置嵌套页面位置 
  var eL=(screen.availWidth-dF.style.pixelWidth)/2;
  var eT=(screen.availHeight - dF.style.pixelHeight)/2;
  dF.style.left=eL;
  dF.style.top=eT;
  if("none"==dF.style.display) 
  	dF.style.display="block";
}

//============================================ajax部分====================
var http_request=false;
var show_block=false;
//发送请求
function singleRequest(url){
	show_block = null;
	//浏览器兼容性设定
    if (window.XMLHttpRequest) { //使用与非IE浏览器 Mozilla, Safari
        http_request = new XMLHttpRequest();
        if (http_request.overrideMimeType) {
            http_request.overrideMimeType('text/html');
        }
    } else if (window.ActiveXObject) { //使用IE浏览器
        try {
            http_request = new ActiveXObject("Msxml2.XMLHTTP");
        } catch (e) {
            try {
                http_request = new ActiveXObject("Microsoft.XMLHTTP");
            } catch (e) {}
        }
    }
    if (!http_request) {
        alert('您的浏览器不支持xmlhttp！为了您的正常使用，请选择IE浏览器或者firefox');
        return false;
    }
	http_request.onreadystatechange = processRequest;
	http_request.open("GET", url, true);
	http_request.send(null);
 }
 
 //发送请求
function sendRequest(url,str){
	show_block = str;
	//浏览器兼容性设定
    if (window.XMLHttpRequest) { //使用与非IE浏览器 Mozilla, Safari
        http_request = new XMLHttpRequest();
        if (http_request.overrideMimeType) {
            http_request.overrideMimeType('text/html');
        }
    } else if (window.ActiveXObject) { //使用IE浏览器
        try {
            http_request = new ActiveXObject("Msxml2.XMLHTTP");
        } catch (e) {
            try {
                http_request = new ActiveXObject("Microsoft.XMLHTTP");
            } catch (e) {}
        }
    }

    if (!http_request) {
        alert('您的浏览器不支持xmlhttp！为了您的正常使用，请选择IE浏览器或者firefox');
        return false;
    }
    //显示为正在执行
    document.getElementById(show_block).innerHTML = "<img src='http://www.51logou.com/images/ajax/loading.gif' width='19px' height='18px'>";
    
	http_request.onreadystatechange = processRequest;
	http_request.open("GET", url, true);
	http_request.send(null);
 }
 
 function processRequest(){
     if (http_request.readyState == 4 && http_request.status == 200){
	    callback(http_request);
     }else{
      	return false;
     }
 }
 
//ajax请求回调方法
function callback(http_request){
	if(show_block != null){
		set_innerHTML(show_block, http_request.responseText);
	}
	ajaxFlag=false;
	//document.getElementById(show_block).innerHTML = http_request.responseText;
}
/**
 *创建request对像
 */
function newXMLHttpRequest() {
	  var xmlreq = false;
	  if (window.XMLHttpRequest) {
	    xmlreq = new XMLHttpRequest();
	
	  } else if (window.ActiveXObject) {
	
	    try {
	      xmlreq = new ActiveXObject("Msxml2.XMLHTTP");
	      
	    } catch (e1) {
	      try {
	        xmlreq = new ActiveXObject("Microsoft.XMLHTTP");
	
	      } catch (e2) {
	        xmlreq = false;
	      }
	    }
	  }
	return xmlreq;
}
/**
 *发关请求
 */
	function xhrSend(url,processMethod,xhrarg){
		var req = newXMLHttpRequest();
        req.onreadystatechange = function(){
        	if (req.readyState == 4) {
	      	 if (req.status == 200) {
	      	 if(typeof(processMethod)=="function")
	       	 	 processMethod(req,xhrarg);
	      	 } else {
	        	 alert("HTTP error "+req.status+": "+req.statusText);
	      	 }
	   	  }
        }
        req.open("GET",url, true);
        req.send(null);
	}
	
//返回文本中如果带有JS需要执行==
var global_html_pool = [];
var global_script_pool = [];
var global_script_src_pool = [];
var global_lock_pool = [];
var innerhtml_lock = null;
var document_buffer = "";

function set_innerHTML(obj_id, html, time) {
    if (innerhtml_lock == null) {
        innerhtml_lock = obj_id;
    }
    else if (typeof(time) == "undefined") {
        global_lock_pool[obj_id + "_html"] = html;
        window.setTimeout("set_innerHTML('" + obj_id + "', global_lock_pool['" + obj_id + "_html']);", 10);
        return;
    }
    else if (innerhtml_lock != obj_id) {
        global_lock_pool[obj_id + "_html"] = html;
        window.setTimeout("set_innerHTML('" + obj_id + "', global_lock_pool['" + obj_id + "_html'], " + time + ");", 10);
        return;
    }

    function get_script_id() {
        return "script_" + (new Date()).getTime().toString(36)
          + Math.floor(Math.random() * 100000000).toString(36);
    }

    document_buffer = "";

    document.write = function (str) {
        document_buffer += str;
    }
    document.writeln = function (str) {
        document_buffer += str + "\n";
    }

    global_html_pool = [];

    var scripts = [];
    html = html.split(/<\/script>/i);
    for (var i = 0; i < html.length; i++) {
        global_html_pool[i] = html[i].replace(/<script[\s\S]*$/ig, "");
        scripts[i] = {text: '', src: '' };
        scripts[i].text = html[i].substr(global_html_pool[i].length);
        scripts[i].src = scripts[i].text.substr(0, scripts[i].text.indexOf('>') + 1);
        scripts[i].src = scripts[i].src.match(/src\s*=\s*(\"([^\"]*)\"|\'([^\']*)\'|([^\s]*)[\s>])/i);
        if (scripts[i].src) {
            if (scripts[i].src[2]) {
                scripts[i].src = scripts[i].src[2];
            }
            else if (scripts[i].src[3]) {
                scripts[i].src = scripts[i].src[3];
            }
            else if (scripts[i].src[4]) {
                scripts[i].src = scripts[i].src[4];
            }
            else {
                scripts[i].src = "";
            }
            scripts[i].text = "";
        }
        else {
            scripts[i].src = "";
            scripts[i].text = scripts[i].text.substr(scripts[i].text.indexOf('>') + 1);
            scripts[i].text = scripts[i].text.replace(/^\s*<\!--\s*/g, "");
        }
    }

    var s;
    if (typeof(time) == "undefined") {
        s = 0;
    }
    else {
        s = time;
    }

    var script, add_script, remove_script;

    for (var i = 0; i < scripts.length; i++) {
        var add_html = "document_buffer += global_html_pool[" + i + "];\n";
        add_html += "document.getElementById('" + obj_id + "').innerHTML = document_buffer;\n";
        script = document.createElement("script");
        if (scripts[i].src) {
            script.src = scripts[i].src;
            if (typeof(global_script_src_pool[script.src]) == "undefined") {
                global_script_src_pool[script.src] = true;
                s += 2000;
            }
            else {
                s += 10;
            }
        }
        else {
            script.text = scripts[i].text;
            s += 10;
        }
        script.defer = true;
        script.type =  "text/javascript";
        script.id = get_script_id();
        global_script_pool[script.id] = script;
        add_script = add_html;
        add_script += "document.getElementsByTagName('head').item(0)";
        add_script += ".appendChild(global_script_pool['" + script.id + "']);\n";
        window.setTimeout(add_script, s);
        remove_script = "document.getElementsByTagName('head').item(0)";
        remove_script += ".removeChild(document.getElementById('" + script.id + "'));\n";
        remove_script += "delete global_script_pool['" + script.id + "'];\n";
        window.setTimeout(remove_script, s + 10000);
    }

    var end_script = "if (document_buffer.match(/<\\/script>/i)) {\n";
    end_script += "set_innerHTML('" + obj_id + "', document_buffer, " + s + ");\n";
    end_script += "}\n";
    end_script += "else {\n";
    end_script += "document.getElementById('" + obj_id + "').innerHTML = document_buffer;\n";
    end_script += "innerhtml_lock = null;\n";
    end_script += "}";
    window.setTimeout(end_script, s);
}
//============================================ajax部分_end=====================
 //其他验证方法
/*-------------- 函数检索 --------------
 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)
 
 校验字符串是否为中文:                checkIsChinese(str)
 计算字符串的长度，一个汉字两个字符:   realLength()
 校验字符串是否符合自定义正则表达式:   checkMask(str,pat)
 得到文件的后缀名:                   getFilePostfix(oFile)  
 检查邮箱是否合法:                   checkIsEmail(str)
 检查电话号码是否合法:               checkIsTelephone(str)
 检查手机是否合法:                   checkIsMobilephone(str)
 检查是不是数字与26个字母子           checkIsNumbericOrEnglish(str)
 得到指定位数的字母与数字组合的随机数	 getRandom(bytes)
 -------------- 函数检索 --------------
*/

/**
 * added by Supermna 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 **************************************/
/**
*校验字符串是否为空
*返回值：
*如果不为空，供%网管b=s垠nZT#3)B网Pw育iA%定义校验通过，返回true
*如果为空，校验不通过，返回false               参考提示信息：输入域不能为空！
*/
function checkIsNotEmpty(str)
{
    if(str.trim() == "")
        return false;
    else
        return true;
}//~~~
/*--------------------------------- 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;
    //如果是整数，网T"K$Q网s4络zFk8~则校验整数的有效性
    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 -----------------------------------------*/
/********************************** 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
*如果字串符合，B的eGDUFO_[$C校验通过，           返回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 Supermna 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;
}//~~~
/*--------------------------------- file --------------------------------------*/
/*********************************Email*****************************************/
function checkIsEmail(str) {
	var reg = /^([a-zA-Z0-9_\-\.]+)?[a-zA-Z0-9]@([a-zA-Z0-9]+(-[a-zA-Z0-9]+)?\.)+[a-zA-Z]{2,}$/;
	if (!reg.exec(str)) {
	    return false;
	}else{
	return true;
	}
}
/*--------------------------------- email --------------------------------------*/
/*********************************telephone*****************************************/
function checkIsTelephone(str) {
	var reg = /^(([0-9]{3,4})|[0-9]{3,4}-)?[0-9]{7,8}$/;
	if (!reg.exec(str)) {
	    return false;
	}else{
	return true;
	}
}
/*--------------------------------- telephone --------------------------------------*/
/*********************************mobilephone*****************************************/
function checkIsMobilephone(str) {
	var reg = /^0{0,1}1[35][0-9]{9}$/;
	if (!reg.exec(str)) {
	    return false;
	}else{
	return true;
	}
}
/*--------------------------------- mobilephone --------------------------------------*/
/***********************************检查是不是数字与26个字母子***************************/
function checkIsNumbericOrEnglish(str) {
	var reg = /^[a-zA-Z0-9]+$/;
	
		if (!reg.exec(str)) {
			return false;
		}else{
			return true;
	    }
}
/*--------------------------------------检查是不是数字与26个字母子----------------------*/
/********************************** random ***************************************/
/**
 * added by david 2007.12.03
 * 得到指定位数的字母与数字组合的随机数
 * bytes为指定的位数
 */
function getRandom(bytes) {
    var str = "qwertyuiopasdfghjklmnbvcxz1234567890";
    var s = str.split("");
    var t = "";
    for (var i = 0; i < bytes; i++) {
        t += s[getRandomNum(1, 36)];
    }
    return t;
}//~~~
/**
 * 随机数算法
 */
function getRandomNum(lbound, ubound) {
    return (Math.floor(Math.random() * (ubound - lbound)) + lbound);
}
/*--------------------------------- random --------------------------------------*/

/**格式化输出积分,传入价格
 */
function outPoint(price){
	var numprice=new Number(price*100);
	temp=numprice.toLocaleString();
	if(temp<=0){
		document.write("0 ");
	}else if(temp.length>3){
		document.write(temp.substring(0,temp.length-3));
	}else{
		document.write(0);
	}	
}
//图片处理
function parseImg(myimg,horw){
	var hw=horw||136;
	var imgH=myimg.clientHeight;
	var imgW=myimg.clientWidth;
	var posTop=0;
	var posLeft=0;
	var rat=1;
	
	if(imgH>imgW){
		myimg.width=hw;
		rat=hw/imgW;
		posTop=(imgH*rat-hw)/2
	}else{
		myimg.height=hw;
		rat=hw/imgH;
		posLeft=(imgW*rat-hw)/2
	}
	
	var pObj=myimg.parentNode;
	while(pObj.nodeName!="DIV"){
		pObj=pObj.parentNode
	};
	//alert(pObj.nodeName);
	pObj.style.position="relative";
	pObj.style.overflow="hidden";
	pObj.style.width=hw;
	pObj.style.height=hw;
	
	myimg.style.position="relative";
	myimg.style.top=-posTop+"px";
	myimg.style.left=-posLeft+"px";	
	
}
//图片效果
function imgOver(obj,src){
	var oImg=new Image();
	obj.src="/images/shopping/white.jpg";//白色图片,可以换成加载效果的图片
	oImg.onload=function(){
		obj.src=oImg.src;
	}
	oImg.src=src;
	obj.className='img200';
	obj.parentNode.style.zIndex='20';
	
}
function imgOut(obj,src){
	obj.src=src;
	obj.className="img120";
	obj.parentNode.style.zIndex="0";
}