function createAjax() {			//该函数将返回XMLHTTP对象实例   
	var _xmlhttp;
	try {
		_xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");	//IE的创建方式
	}
	catch (e) {
		try {
			_xmlhttp=new XMLHttpRequest();	//FF等浏览器的创建方式
		}
		catch (e) {
			_xmlhttp=false;		//如果创建失败，将返回false
		}
	}
	return _xmlhttp;	//返回xmlhttp对象实例
}

function getscrolllist() {		//该函数用来获取滚动数据
	var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getscrolllist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content = document.getElementById('scrolldate');		//获取页面中id为scrolldate的对象
		xmlhttp.open('get','server/server.asp?flag=scroll',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，参数，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}


function getchannellist() {		//该函数用来获取频道信息
	var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getchannellist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('channel');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=channel',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getnewsheadlist() {		//该函数用来获取新闻头条信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	//////alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('newshead');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=xwtt',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getjtywlist() {		//该函数用来获取集团要闻信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('jtyw');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=jtyw',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getmtjjlist() {		//该函数用来获取媒体聚焦信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	/////alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('mtjj');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=mtjj',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getkqdtlist() {		//该函数用来获取矿区动态信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('kqdt');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=kqdt',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getszxwlist() {		//该函数用来获取时政要闻信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('szxw');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=szxw',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function gethyxwlist() {		//该函数用来获取行业新闻信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('hyxw');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=hyxw',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getztbdlist() {		//该函数用来获取公告公示信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('ztbd');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=ztbd',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getgggslist() {		//该函数用来获取公告公示信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('gggs');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=gggs',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.setRequestHeader("Cache-Control","no-cache");
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}


/*///////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////   上面为新闻部分
////////////////////////////   以下为文化广场部分
////////////////////////////////////////////////////////////////////////////////////////////////////*/
function getsytdlist() {		//该函数用来获取摄影天地信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('sytd');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=sytd',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

function getshcllist() {		//该函数用来获取书画长廊信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('shcl');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=shcl',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getshgclist() {		//该函数用来获取史海钩沉信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('shgc');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=shgc',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getwyjylist() {		//该函数用来获取文苑撷英信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('wyjy');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=wyjy',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getyjylist() {		//该函数用来获取影剧院信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('yjy');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=yjy',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getyltlist() {		//该函数用来获取音乐厅信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('ylt');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=ylt',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getrwplist() {		//该函数用来获取人物谱信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('rwp');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=rwp',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

/*function getjpsclist() {		//该函数用来获取人物谱信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('jpsc');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=jpsc',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} kgxc*/

function getkgxclist() {		//该函数用来获取矿工相册
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('jpsc');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=kgxc',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getyyxtlist() {		//该函数用来获取应用系统信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('yyxt');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=yyxt',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getscrollimagelist() {		//该函数用来获取图片信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('scrollimage');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=scrollimage',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

function getvideo1list() {		//该函数用来获取新闻视频信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('video');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=video1',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getvideo2list() {		//该函数用来获取专题视频信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('video');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=video2',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

function getvideo3list() {		//该函数用来获取文娱视频信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它	
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('video');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=video3',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

function getvideo4list() {		//该函数用来获取讲座视频信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它	
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('video');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=video4',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

/* //////////////////////////////
    后面三个方法用来取论坛的数据
////////////////////////////*/
function getluntanimage() {		//该函数用来获取论坛的图片
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它	
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('luntanimage');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=luntanimage',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

function getnewpaste() {		//该函数用来获取论坛的图片
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它	
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('newpaste');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=newpaste',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {       	   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

function getlast() {		//该函数用来获取精华
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它	
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('last');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/server.asp?flag=last',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

function getwebcount() {		//该函数用来获取网站总反问量
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('webcount');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/count.asp?flag=kqdt',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

/*
 *首页加载页面方法调用
*/
function loadAllFunction(){
	getchannellist();      //导航条
	 getscrolllist();          //滚动新闻
    getnewsheadlist();   //新闻头条
	 getjtywlist();           //集团要闻
	 getmtjjlist();           //媒体聚焦
	 getkqdtlist();          //矿区动态
	 getszxwlist();         //时政要闻
	 gethyxwlist();         //行业新闻
	 getztbdlist();          //专题报道
	 getgggslist();        //公告公示	 
	 
	 getsytdlist();        // 摄影天地
	 getshcllist();         //文化长廊
	 getshgclist() ;      //史海钩沉 
	 getwyjylist();        //文苑撷英
	 //getyjylist();   //影剧院
	 getyltlist();           //音乐厅
	 getrwplist();        //人物谱
	 //getjpsclist()         //精品收藏
	getkgxclist();             //矿工相册
	 
	 getscrollimagelist() ;    //图片新闻
	 getvideo1list();             //新闻
	 
	 getluntanimage();       // 论坛图片
	getnewpaste(); //最新发帖
	 getlast();              //本月精华
	 getwebcount() ;    //本网站总反问量
}

function loadspe(flag){           //集团概况和联系我们页面用的方法
		getwebconten(flag);         //
		getchannellist();               //导航条
		getscrolllist();                 //滚动新闻	
		getkywqlist();                 //矿业网群
}


function loadleaderfunction(target,flag){  //领导页面调用
   getweblist(target,flag);      //内容列表
	getchannellist();               //导航条
	 getscrolllist();                 //滚动新闻
	 getlefttoplist(flag)           //网页左上角的数据
	 getkywqlist();                 //矿业网群
	 getleaders(flag)              //得到领导介绍
   gettotalpage(flag);                 //得到总的分页数
	setTimeout("setpage('"+flag+"')", 3000);    //调用分页	
}



function loadImagefunction(target,flag){   //摄影天地模块、书画长廊、精品收藏
     getweblist(target,flag);      //内容列表
     gettotalpage(flag);              //得到总的分页数
	 setTimeout("setpage('"+flag+"')",3000);    //调用分页
}

function searchfunction(){  //站内搜索
      var rs = getQueryStr("searchkey");
		var flag ="search_"+rs
		////alert(flag);
		getchannellist();               //导航条
	   getscrolllist();                 //滚动新闻
		getweblist(1,flag);      //内容列表
		getkywqlist();                 //矿业网群
		gettotalpage(flag);                 //得到总的分页数
	  setTimeout("setpage('"+flag+"')", 3000);    //调用分页	
}

/*///////////////////////////////////
///                             /////
///      个人图片显示图片列表   /////
///////////////////////////////////*/
function personImage(target,flag){
      ///alert(flag);             
	   getleaders(flag);                //得到作者信息
		getweblist(target,flag);      //内容列表
		///document.getElementById("setpage").innerHTML =""
		gettotalpage(flag);                 //得到总的分页数
	   setTimeout("setpage('"+flag+"')", 3000);    //调用分页
		////alert("******");
}

/*
 *****************************************
 ****    公共单个页面调用加载方法    *****
 *****************************************
*/
function loadPagefunction(target,flag){
		if (flag=="zyxz"){
			///alert("***********");
		     getzyxz3(target,flag);
			  
		}else{
			getchannellist();               //导航条
			getscrolllist();                 //滚动新闻
			getlefttoplist(flag)           //网页左上角的数据   --添加新的要修改
			getkywqlist();                 //矿业网群
			getweblist(target,flag);      //内容列表             --添加新的要修改
			gettotalpage(flag);                 //得到总的分页数 --添加新的要修改
			///alert("88888888")
			setTimeout("setpage('"+flag+"')", 3000);    //调用分页
		}
		
}

function getwebconten(flag) {		//该函数用来获取矿业网群信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('contentlist');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/pageServer.asp?flag='+flag,true);	//打开与服务器的连接，其中get为连接方式，pageServer.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getleaders(flag) {		//该函数用来获取领导介绍信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('leaders');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/leaders.asp?flag='+flag,true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
} 

/*
 *公共的页面调用方法
*/
function getweblist(page,flag) {		//该函数用来获取分页数据中每页的内容
	var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('contentlist');		//获取页面中id为 contentlist 的对象
		xmlhttp.open('get','server/pageServer.asp?flag='+flag+'&page='+page+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，pageServer.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
			 
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。			   
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getlefttoplist(flag) {		//该函数用来获取左边领部频道信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('topleftcontent');		//获取页面中id为topleftcontent的对象
		xmlhttp.open('get','server/pageChannel.asp?flag='+flag,true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

function getkywqlist() {		//该函数用来获取矿业网群信息
	var xmlhttp=createAjax();	   //创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	///alert("getnewsheadlist  ******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('minegroup');		//获取页面中id为channel的对象
		xmlhttp.open('get','server/pageServer.asp?flag=kywq',true);	//打开与服务器的连接，其中get为连接方式，server.asp为要连接的页面，其中第一个参数flag为需要返回数据的代码块,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		   //为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}


////下面的方法为公共的分页方法
var totalpage,pagesize,cpage,count,curcount,outstr,ip; 
//初始化 
cpage = 1;
pagesize = 20; 
outstr = ""; 
function gotopage(target,flag) 
{     
    cpage = target;               //把页面计数定位到第几页 
    setpage(flag);    
	 getweblist(target,flag);
	 ////alert("**********");
} 

function setpage(flag) 
{ 
   ///alert("setpage");
    if(totalpage<=20){        //总页数小于十页 
        for (count=1;count<=totalpage;count++) 
        {    if(count!=cpage) 
            {
                outstr = outstr + "<a href='javascript:void(0)'  class='ys' onclick='gotopage("+count+",\""+flag+"\")'>["+count+"]</a>"; 
            }else{ 
                outstr = outstr + "<span class='ys' > "+count+" </span>"; 
            } 
        } 
    } 
	 
    if(totalpage>20){        //总页数大于十页 
        if(parseInt((cpage-1)/20) == 0) 
        {
            for (count=1;count<=20;count++) 
            {    if(count!=cpage) 
                { 
                    outstr = outstr + "<a href='javascript:void(0)'  class='ys' onclick='gotopage("+count+",\""+flag+"\")'>["+count+" ]</a>"; 
                }else{ 
                    outstr = outstr + "<span class='ys'>  "+count+"  </span>"; 
                } 
            } 
            outstr = outstr + "<a href='javascript:void(0)'   class='ys' onclick='gotopage("+count+",\""+flag+"\")'> <font face=webdings>:</font> </a>"; 
        } 
        else if(parseInt((cpage-1)/20) == parseInt(totalpage/20)) 
        {     
            outstr = outstr + "<a href='javascript:void(0)' class='ys' onclick='gotopage("+(parseInt((cpage-1)/20)*20)+",\""+flag+"\")'>  <font face=webdings>9</font>  </a>"; 
            for (count=parseInt(totalpage/20)*20+1;count<=totalpage;count++) 
            {    if(count!=cpage) 
                { 
                    outstr = outstr + "<a href='javascript:void(0)'  class='ys' onclick='gotopage("+count+",\""+flag+"\")'> ["+count+"] </a>"; 
                }else{ 
                    outstr = outstr + "<span class='ys'>   "+count+"  </span>"; 
                } 
            }
        } 
        else 
        {
            outstr = outstr + "<a href='javascript:void(0)'  class='ys'  onclick='gotopage("+(parseInt((cpage-1)/20)*20)+",\""+flag+"\")'>  <font face=webdings>9</font>  </a>"; 
            for (count=parseInt((cpage-1)/20)*20+1;count<=parseInt((cpage-1)/20)*20+20;count++) 
            {
                if(count!=cpage) 
                { 
                    outstr = outstr + "<a href='javascript:void(0)'   class='ys' onclick='gotopage("+count+",\""+flag+"\")'>  ["+count+"]  </a>"; 
                }else{ 
                    outstr = outstr + "<span class='ys'>  "+count+" </span>"; 
                } 
            } 
            outstr = outstr + "<a href='javascript:void(0)' class='ys' onclick='gotopage("+count+",\""+flag+"\")'>   <font face=webdings>:</font>   </a>"; 
        } 
    }
	 
    document.getElementById("setpage").innerHTML = "<span id='info' class='ys' >共 "+totalpage+"页 | 第"+cpage+"页 <\/span>        " + outstr + ""; 
    outstr = ""; 
}

function gettotalpage(flag) {		//该函数用来获取分页数据中记录总数
	var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		///var content=document.getElementById('totalpage');		//获取页面中id为 totalpage 的对象
		xmlhttp.open('get','server/totalpage.asp?flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
			 
			 totalpage = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。			   
			
			}else {
				//////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}
/*
 *********************************************
 ****    公共单个页面调用加载方法结束    *****
 *********************************************
*/


/*************************
  三级目录通用页面调用方法

**************************/

function loadthreePagefunction(target,flag){
	  var channelid = document.getElementById("channelid").value
		getchannellist();               //导航条
		getscrolllist();                 //滚动新闻 
		 getleaders('topimage_'+channelid)    //
		getlefttoplist(flag)           //网页左上角的数据
		getkywqlist();                 //矿业网群
		getweblist(target,flag);      //内容列表
		gettotalpage(flag);                 //得到总的分页数
		setTimeout("setpage('"+flag+"')", 3000);    //调用分页		
}


/*************************
  四级目录通用页面调用方法

**************************/
function loadfourPagefunction(target,flag){
	  var channelid = document.getElementById("channelid").value
		getchannellist();               //导航条
		getscrolllist();                 //滚动新闻 
		 getleaders('topimage2_'+channelid)    //
		getlefttoplist(flag)           //网页左上角的数据
		getkywqlist();                 //矿业网群
		getweblist(target,flag);      //内容列表
		gettotalpage(flag);                 //得到总的分页数
		setTimeout("setpage('"+flag+"')", 3000);    //调用分页		
}




/*//////////////////////////////////////////////
///////   取图片公共方法             ///////////
///////////////////////////////////////////////*/
/*
   该函数用来取地址栏的参数
*/
function getQueryStr(str){
        var LocString=String(window.document.location.href); 
        var rs = new RegExp("(^|)"+str+"=([^\&]*)(\&|$)","gi").exec(LocString), tmp;          
       
		 if(tmp=rs){
            return tmp[2]; 
        }
        // parameter cannot be found   
        return "";
 }

function image_info(){
    var info_id  = getQueryStr("info_id");
	 var channel_id  = getQueryStr("channel_id");
	///// alert("*******");
	getImage_Info(info_id,channel_id,"");
	
}

function  getpersonlist()  { 
  var flag = getQueryStr("channelid");
   personImage(1,flag);
}

function getminegroup(){   ////该方法用来得到矿业网群信息
   var info_id = getQueryStr("infoid");
	getchannellist();               //导航条
	getscrolllist();                 //滚动新闻		
	getkywqlist();                 //矿业网群
	getImage_Info(info_id,"","kywq") //矿业网群内容
	
}

function getsonplay(){ //方法用来调用播放歌曲
    var info_id = getQueryStr("infoid");
	 getweblist(info_id,"play") ; //调用歌曲播放内容
}

function getImage_Info(info_id,channel_id,flag) {		//该函数用来获取图片和介绍
	var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	////alert("******");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('ImageContent');		//获取页面中id为 ImageContent 的对象
		xmlhttp.open('get','server/pageImageserver.asp?info_id='+info_id+'&channel_id='+channel_id+'&flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，pageImageserver.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
			 content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。			   
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}






/**********************************************

************   生成文件要用的方法  ************

***********************************************/
function getcount(){ //该方法用来加载共有评论和点击率和添加点击率
	
	var infoid = document.getElementById('infoid').value;		//获取页面中id为
	var channelid = document.getElementById('channelid').value;		//获取页面中id为
	    getdot(infoid,channelid,'click')         //得到点击率
		 getNumberDot(infoid,channelid,'punlunnumber') //得到评论数量和跳到评论列表			 
					 
}

function getdot(infoid,channelid,flag){  //得到点击率
   var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	var content=document.getElementById('click');		//获取页面中id为  的对象
	 if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序			
			xmlhttp.open('get','../../server/remarkServer.asp?infoid='+infoid+'&channelid='+channelid+'&flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，pageImageserver.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
			xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
				if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				   content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。			   
				}
			}
			xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
		}
}

function getNumberDot(infoid,channelid,flag){  //得到评论数量和跳到列表
   var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	var content = document.getElementById('punlunnumber');		//获取页面中id为  的对象	
	  if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序			
			xmlhttp.open('get','../../server/remarkServer.asp?infoid='+infoid+'&channelid='+channelid+'&flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，pageImageserver.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
			xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
				if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				  content.innerHTML = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。			   
				}
			}
			xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
		}
}

function getNumberDot2(infoid,channelid,flag){  //得到评论数量和跳到列表
   var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	var content = document.getElementById('punlunnumber');		//获取页面中id为  的对象	
	  if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序			
			xmlhttp.open('get','server/remarkServer.asp?infoid='+infoid+'&channelid='+channelid+'&flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，pageImageserver.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
			xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
				if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				  content.innerHTML = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。			   
				}
			}
			xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
		}
}

 function nextNews(flag){     //下一条、上一条
 var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它    
	 var infoid = document.getElementById('infoid').value;		//获取页面中id为
	  var channelid = document.getElementById('channelid').value;		//获取页面中id为
     if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序			
			xmlhttp.open('get','../../server/remarkServer.asp?infoid='+infoid+'&channelid='+channelid+'&flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
			xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
				if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
				 //// alert(unescape(xmlhttp.responseText));
				 self.location.href=unescape(xmlhttp.responseText);
				  ///window.open(unescape(xmlhttp.responseText),"");
				}
			}
			xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
		}
 }


function loadremark(target, flag){            //评论列表页面加载方法
    var info_id = getQueryStr("info_id");
    document.getElementById('infoid').value = info_id;
	 var flag ="pllist_"+info_id;
	 gettopic(info_id,'','topic');                            //评论的标题
	 getweblist(target,flag);                                //评论内容列表
	 getNumberDot2(info_id,"","punlunnumber2") //得到评论的数量和列表跳转
	 gettotalpage(flag);                                      //得到总的分页数
	 setTimeout("setpage('"+flag+"')", 3000);      //调用分页
}

function gettopic(infoid,channelid,flag) {		//该函数用来加载评论列表(评论列表页面)
	var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var content=document.getElementById('tipic');		//获取页面中id为  的对象
		xmlhttp.open('get','server/remarkServer.asp?infoid='+infoid+'&channelid='+channelid+'&flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，pageImageserver.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
			   content.innerHTML=unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。			   
			}
			else {
				content.innerHTML='<img border="0"  align="middle" src="image/loading.gif" />';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

/////该方法用来提交评论内容
function postRemark(flag) {		//该函数用来提交评论内容
	var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	////alert("******flag   " +flag );
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var infoid = document.getElementById('infoid').value;		//获取页面中id为
		var channelid = document.getElementById('channelid').value;		//获取页面中id为
		var nicheng = document.getElementById('nicheng').value;		//获取页面中id为
		var pl_content = document.getElementById('pl_content').value;		//获取页面中id为
		var sendData = 'infoid='+infoid+'&channelid='+channelid+'&nicheng='+encodeURIComponent(encodeURIComponent(nicheng))+'&pl_content='+encodeURIComponent(encodeURIComponent(pl_content));
	   xmlhttp.open('post','../../server/remarkServer.asp?flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，pageImageserver.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
	   xmlhttp.setRequestHeader("Cache-Control","no-cache");
		xmlhttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded;");
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
			    	document.getElementById('nicheng').value="";
				   document.getElementById('pl_content').value="";
				 window.open("../../remark.html?info_id="+infoid,"内容评论");				
			}
		}
		xmlhttp.send(sendData);//要POST的数据	
	}
}

/////该方法用来提交评论内容
function postRemark2(flag) {		//该函数用来提交评论内容
	var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	////alert("******flag   " +flag );
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		var infoid = document.getElementById('infoid').value;		//获取页面中id为
		var channelid = document.getElementById('channelid').value;		//获取页面中id为
		var nicheng = document.getElementById('nicheng').value;		//获取页面中id为
		var pl_content = document.getElementById('pl_content').value;		//获取页面中id为		
		var sendData = 'infoid='+infoid+'&channelid='+channelid+'&nicheng='+encodeURIComponent(encodeURIComponent(nicheng))+'&pl_content='+encodeURIComponent(encodeURIComponent(pl_content));
	 
		xmlhttp.open('post','server/remarkServer.asp?flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，pageImageserver.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		//xmlhttp.setrequestheader("content-length",sendData.length);
		xmlhttp.setRequestHeader("Cache-Control","no-cache");
		xmlhttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded;");
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
			    	document.getElementById('nicheng').value="";
				   document.getElementById('pl_content').value="";
					 flag="pllist_"+infoid
					 ///alert("flag ="+flag);
					 getweblist(1,flag);                                //评论内容列表
					 getNumberDot2(infoid,"","punlunnumber2") //得到评论的数量和列表跳转
					 gettotalpage(flag);                                      //得到总的分页数
					 setTimeout("setpage('"+flag+"')", 3000);      //调用分页
				 
			}
		}
		xmlhttp.send(sendData);//要POST的数据	
	}
}

//首页讲座
function getclient(flag){
    flag=""
  var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		xmlhttp.open('get','server/getclient.asp?flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
		   ip=""
			ip = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并付给变量。
          //alert(ip);			 
			 if( ip == "10" || ip == "137" || ip == "172" || ip == "192" ){
			     getvideo4list();
			  }else{
			     window.open("nb.html","");
			  }
			}else {
				//////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

//首页影剧院
function getyjyip(){
    flag=""
  var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		xmlhttp.open('get','../server/getclient.asp?flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
          ip=""		   
			ip = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并付给变量。
          //alert(ip);			 
			 if( ip == "10" || ip == "137" || ip == "172" || ip == "192" ){			      
					 window.open("../yjy.html","");
			  }else{
			     window.open("../nb.html","");
			  }
			}else {
				//////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

//首页资源下载
function getzyxz(){
    flag=""
  var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		xmlhttp.open('get','server/getclient.asp?flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
		    ip=""
			 ip = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并付给变量。
          //alert(ip);			 
			 if( ip == "10" || ip == "137" || ip == "172" || ip == "192" ){			      
					 window.open("resouredownload.html","");
			  }else{
			     window.open("nb.html","");
			  }
			}else {
				//////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

//二级页面资源下载
function getzyxz2(){
    flag=""
  var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		xmlhttp.open('get','../../server/getclient.asp?flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
          ip=""		   
			ip = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并付给变量。
          //alert(ip);			 
			 if( ip == "10" || ip == "137" || ip == "172" || ip == "192" ){			      
					 window.open("../../resouredownload.html","");
			  }else{
			     window.open("../../nb.html","");
			  }
			}else {
				//////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}

//资源下载控制直接输入地址
function getzyxz3(target,flags){
    flag=""
  var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		xmlhttp.open('get','server/getclient.asp?flag='+flag+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
		    ip=""
			 ip = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并付给变量。
           //alert(ip);			 
			 if( ip == "10" || ip == "137" || ip == "172" || ip == "192" ){			      
					getchannellist();               //导航条
					getscrolllist();                 //滚动新闻
					getlefttoplist(flags)           //网页左上角的数据
					getkywqlist();                 //矿业网群
					getweblist(target,flags);      //内容列表
					gettotalpage(flags);                 //得到总的分页数
					setTimeout("setpage('"+flags+"')", 3000);    //调用分页
			  }else{
			     self.location.href="nb.html"
			  }

   
	
	}else {
				//////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
}


function getpageclient(flag,infoid){
  var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	//var infoid = = getQueryStr("infoid");
	//alert("getpageclient   flag = "+flag);
	//window.open("play.html?infoid="+infoid,"");
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		///var content=document.getElementById('totalpage');		//获取页面中id为 totalpage 的对象
		xmlhttp.open('get','../server/getclient.asp?flag=&infoid='+infoid+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
		    ip = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
            //alert(ip);			 
		  if( ip == "10" || ip == "137" || ip == "172" || ip == "192" ){
			  
			 geturl(flag,infoid);
			
			}else{
			    window.open("../nb.html","");
			}
			}else {
				  //////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}

}

//影剧院 //应用系统 /讲座
function geturl(flag,infoid){ 
  var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	//var infoid = = getQueryStr("infoid");
	//alert(flag);
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		///var content=document.getElementById('totalpage');		//获取页面中id为 totalpage 的对象
		xmlhttp.open('get','../server/getclient.asp?flag='+flag+'&infoid='+infoid+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		//alert('server/getclient.asp?flag='+flag+'&infoid='+infoid+'&n='+Math.random());
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
		      url = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
			  window.open(url,"");
			}else {
				  //////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
  
}


/*
 *  列表用的
 *
*/
function getpageclient2(flag,infoid){
  var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	//var infoid = = getQueryStr("infoid");
	//alert("getpageclient2   flag = "+flag);
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		///var content=document.getElementById('totalpage');		//获取页面中id为 totalpage 的对象
		xmlhttp.open('get','server/getclient.asp?flag=&infoid='+infoid+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
		    ip = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
         // alert(ip);			 
		  if( ip == "10" || ip == "137" || ip == "172" || ip == "192" ){
			   if (flag=="song")
			   {
                 window.open("play.html?infoid="+infoid,"");
			   }else{
				 geturl2(flag,infoid);
			   }
			}else{
			    //geturl2(flag,infoid);			
			    window.open("nb.html","");
			}
			}else {
				  //////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}

}

//影剧院 //应用系统 /讲座
function geturl2(flag,infoid){ 
  var xmlhttp=createAjax();	//创建变量xmlhttp，并将createAjax()函数创建的对象实例赋于它
	//var infoid = = getQueryStr("infoid");
	//alert(flag);
	if (xmlhttp) {		//如果xmlhttp对象创建成功，则执行条件语句中的程序
		///var content=document.getElementById('totalpage');		//获取页面中id为 totalpage 的对象
		xmlhttp.open('get','server/getclient.asp?flag='+flag+'&infoid='+infoid+'&n='+Math.random(),true);	//打开与服务器的连接，其中get为连接方式，totalpage.asp为要连接的页面，有两个参数，其中第一个参数page为需要返回数据的页数,第二个参数n为一个随机数，这样每次发送的URL都会不一样，相当于都向服务器发出一个新的请求，避免浏览器缓存数据。
		//alert('server/getclient.asp?flag='+flag+'&infoid='+infoid+'&n='+Math.random());
		xmlhttp.onreadystatechange=function() {		//为xmlhttp对象的readyState属性指定事件，改属性值改变时，则会执行其中的程序
			if (xmlhttp.readyState==4 && xmlhttp.status==200) {	//如果xmlhttp.readyState==4并且xmlhttp.status==200时，执行条件中的程序，其中readyState有五个值，4为请求完成，是客户端向服务器提交的数据成功到达，status有N多值-_-!!，其中200为OK，是指服务器向客户端完成发送数据。
		      url = unescape(xmlhttp.responseText);	//将服务器返回的数据解码并写入指定的ID中。
				window.open(url,"");
			}else {
				  //////content.innerHTML='<span style="color:red">正在从服务器提取数据......</span>';	//如果服务器没有完成传送，则向用户提示正在传输。
			}
		}
		xmlhttp.send(null);	//向服务器发送请求，因为是get请求，会直接附在URL后面，所以这里括号中的数据为null，IE中也可以不写，但FF就必须加上null，否则会发送失败。
	}
  
}