/*************************************************************************
	java script for handling AutoantigenDB user interaction
	Shane Zhang, Bioinformatics IMB, UQ
	s.zhang@imb.uq.edu.au
	Date created: 2006-02-28
	Major update: 2006-03-30, 2006-05-10
*************************************************************************/
	var objHttp_Antigen = null;
	var myId = null;
	
	/*
	* add new div id into this array
	*/
	var Sections = new Array(
								"antigen_browse", 
								"antigen_search", 
								"antigen_blast", 
								"antigen_align", 
								"rankpep_tcell", 
								"multipred_pbp", 
								"autoantigen_web_db",
								"blast_result",
								"search_result",
								"align_result",
								"rankpep_result",
								"multipred_result" 
								);
	
	function Exit() {
		window.close();
	}
	
	function initialiseHttp() {
		objHttp_Antigen = getHttpRequest();
	}
	
	function getHttpRequest() {
		try {
			return new ActiveXObject("Msxml2.XMLHTTP");
		} catch (e) {}
		
		try {
			return new ActiveXObject("Microsoft.XMLHTTP");
		} catch (e) {}
		
		try {
			return new XMLHttpRequest();
		} catch (e) {}
		
		alert ("Your browser does not support XMLHttpRequest!");
		return null;
	}
	
	/*
	*	connect to autoantigen server and retrieve 3D structure files for JMolApplet
	*/
	function retrieveJmol3DFiles() {
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var jmolFileUrl = "http://discovery.imb.uq.edu.au/cgi-bin/GetJMol3D.cgi";
		var txtResult = null;
		var pStart = -1;
		var pEnd = -1;
		var strFileList = null;
		var strMsg = null;
		var jmolFiles = null;
		var optList = document.getElementById('jmol_3d_files');
		var errMsg = document.getElementById('process_err_msg');
		
		if (!optList) {
			alert('Cannot find your SELECT option list named: jmol_3d_files');
			return;
		}
		
		objHttp_Antigen.open('GET', jmolFileUrl, false);
		objHttp_Antigen.send(null);
		
		if (objHttp_Antigen.readyState == 4) {
			txtResult = objHttp_Antigen.responseText;
			
			/*
			*	check tag name JMOLFILE
			*/
			pStart = txtResult.indexOf("<JMOLFILE>");
			pEnd = txtResult.indexOf("</JMOLFILE>");
			if (pStart != -1 && pEnd != -1) {
				strFileList = txtResult.substring(pStart + 10, pEnd);
				strFileList = trim(strFileList);

				if (!strFileList) {
					return;
				}
				
				//split the file list string and populate the select option list				
				jmolFiles = strFileList.split(";");
				for (i = 0; i < jmolFiles.length; i++) {
					var txtFile = jmolFiles[i];
					var opt = new Option(txtFile, txtFile);
					optList.options[optList.options.length] = opt;
				}
				resetError("&nbsp;");
				return;
			}
			
			/*
			*	else, check tag name ERROR
			*/
			pStart = -1;
			pEnd = -1;
			pStart = txtResult.indexOf("<ERROR>");
			pEnd = txtResult.indexOf("</ERROR>");
			if (pStart != -1 && pEnd != -1) {
				strMsg = txtResult.substring(pStart + 7, pEnd);
				strMsg = trim(strMsg); 
				setError(strMsg);
			}
		}
	}
	
	function load3DFile() {
		var optList = document.getElementById('jmol_3d_files');
		var strFileName = null;
		
		if (!optList) {
			alert("Cannot find SELECT option list named: jmol_3d_files");
			resetProcessMsg("None");
			return;
		}
		
		if (optList.options[optList.selectedIndex].value == "NONE") {
			return;
		}
		
		strFileName = "/Structure3D/Antigen3D/" + optList.options[optList.selectedIndex].value;
		setProcessMsg("Jmol is loading structure file ... " );
		jmolScript("load " + strFileName);	
		setProcessMsg("Loaded 3D structure file = " + optList.options[optList.selectedIndex].value);
	}
	
	/*
		browser does not support DOM getElementByTagName !!!
	*/
	function retrieveStatisticsXML() {
		var xmlStatistics = null;
		var statDoc = null;
		var nodRecords = null;
		var nodFamily = null;
		var nodName = null;
		var nodDisease = null;
		var nodHost = null;
		var pElement = null;
		
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {var statDoc = null;
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var statisticsUrl = "http://discovery.imb.uq.edu.au/cgi-bin/AntigenStatistics.cgi";
		objHttp_Antigen.open('GET', statisticsUrl, false);
		objHttp_Antigen.send(null);
		
		if (objHttp_Antigen.readyState == 4) {
			xmlStatistics = objHttp_Antigen.responseXML;
			
			/* why is not this getElementByTagName supported? */
			statDoc = xmlStatistics.getElementByTagName("AutoantigenStatistics");
			
			nodRecords = statDoc.item(0);
			
			if (nodRecords) {
				pElement = document.getElementById("db_record");
				pElement.firstChild.nodeValue = " " + nodRecords.firstChild.data;
			}
			
			nodFamily = statDoc.item(1);
			
			if (nodFamily) {
				pElement = document.getElementById("db_family");
				pElement.firstChild.nodeValue = " " + nodFamily.firstChild.data;
			}
			
			nodName = statDoc.item(2);
			
			if (nodName) {
				pElement = document.getElementById("db_name");
				pElement.firstChild.nodeValue = " " + nodName.firstChild.data;
			}
			
			nodDisease = statDoc.item(3);

			if (nodDisease) {
				pElement = document.getElementById("db_disease");
				pElement.firstChild.nodeValue = " " + nodDisease.firstChild.data;
			}
			
			nodHost = statDoc.item(4);
			
			if (nodHost) {
				pElement = document.getElementById("db_species");
				pElement.firstChild.nodeValue = " " + nodHost.firstChild.data;
			}
		}
	}
	
	/*
	*	connect to autoantigen database server and retrieve statistics
	*/
	
	function retrieveDbStatistics() {
		var txtStatistics = null;
		var strDate = "Unknown";
		var strRecords = "";
		var strFamilies = "";
		var strNames = "";
		var strDiseases = "";
		var strHosts = "";
		var pStart = -1;
		var pEnd = -1;
		var pElement = null;
		
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var statisticsUrl = "http://discovery.imb.uq.edu.au/cgi-bin/AntigenStatistics.cgi";
		objHttp_Antigen.open('GET', statisticsUrl, false);
		objHttp_Antigen.send(null);
		
		if (objHttp_Antigen.readyState == 4) {
			txtStatistics = objHttp_Antigen.responseText;
			
			pStart = txtStatistics.indexOf("<RECORD>");
			pEnd = txtStatistics.indexOf("</RECORD>");
			if (pStart != -1 && pEnd != -1) {
				strRecords = txtStatistics.substring(pStart + 8, pEnd);
				pElement = document.getElementById("db_record");
				pElement.firstChild.nodeValue = " " + strRecords;
			}
			
			pStart = txtStatistics.indexOf("<FAMILY>");
			pEnd = txtStatistics.indexOf("</FAMILY>");
			
			if (pStart != -1 && pEnd != -1) {
				strFamilies = txtStatistics.substring(pStart + 8, pEnd);
				pElement = document.getElementById("db_family");
				pElement.firstChild.nodeValue = " " + strFamilies;
			}
			
			pStart = txtStatistics.indexOf("<NAME>");
			pEnd = txtStatistics.indexOf("</NAME>");
			
			if (pStart != -1 && pEnd != -1) {
				strNames = txtStatistics.substring(pStart + 6, pEnd);
				pElement = document.getElementById("db_name");
				pElement.firstChild.nodeValue = " " + strNames;
			}
			
			pStart = txtStatistics.indexOf("<DISEASE>");
			pEnd = txtStatistics.indexOf("</DISEASE>");
			
			if (pStart != -1 && pEnd != -1) {
				strDiseases = txtStatistics.substring(pStart + 9, pEnd);
				pElement = document.getElementById("db_disease");
				pElement.firstChild.nodeValue = " " + strDiseases;
			}
			
			pStart = txtStatistics.indexOf("<HOST>");
			pEnd = txtStatistics.indexOf("</HOST>");
			
			if (pStart != -1 && pEnd != -1) {
				strHosts = txtStatistics.substring(pStart + 6, pEnd);
				pElement = document.getElementById("db_species");
				pElement.firstChild.nodeValue = " " + strHosts;
			}
			
			pStart = txtStatistics.indexOf("<DATE>");
			pEnd = txtStatistics.indexOf("</DATE>");
			
			if (pStart != -1 && pEnd != -1) {
				strDate = txtStatistics.substring(pStart + 6, pEnd);
				pElement = document.getElementById("db_date");
				pElement.firstChild.nodeValue = " " + strDate;
			}
		}
	}
	
	/*
	*	autoantigen database search by keywords, connect and retrieve
	*/
	function executeAntigenSearch(strKeywords, strOp, strField) {
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var searchUrl = "http://discovery.imb.uq.edu.au/cgi-bin/SearchAntigen.cgi?KEYWORD_AADB=";
		searchUrl += strKeywords + "&FIELD_AADB=" + strField + "&SEARCH_OPT=" + strOp;
		
		if (strKeywords == "EMPTY") {
			StartProcess("Retrieve all antoantigen entries. Please wait ...");
		}
		else {
			StartProcess("Your antigen search is being processed. Please wait ...");
		}
		
		disableSubmit();
		objHttp_Antigen.open('GET', searchUrl, true);		
		objHttp_Antigen.onreadystatechange = retrieveSearchResult;
		objHttp_Antigen.send(null);
	}
	
	/*
	*	blast autoantigen database with query sequence - using method GET
	*/	
	function executeAntigenBlast(strSeq, strType, e_val, intFormat) {
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var blastUrl = "http://discovery.imb.uq.edu.au/cgi-bin/BlastAntigen.cgi?SEQTEXT=";
		blastUrl += strSeq + "&PTYPE=" + strType + "&EVALUE=" + e_val + "&FORMATOUT=" + intFormat;
		
		StartProcess("Autoantigen blast is being processed. Please wait ...");
		disableSubmit();
		
		// change the boolean value if necessary
		objHttp_Antigen.open('GET', blastUrl, true);
		
		//objHttp_Antigen.setRequestHeader('content-Type', 'application/x-www-form-urlencoded'); 
		objHttp_Antigen.onreadystatechange = retrieveBlastResult;
		objHttp_Antigen.send(null);
		//return true;
	}
	
	/*
	*	blast autoantigen database with query sequence - using method POST
	*/
	function executeAntigenBlast_Post(strSeq, strType, e_val, intFormat) {
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var blastUrl = "http://discovery.imb.uq.edu.au/cgi-bin/BlastAntigen.cgi"; 
		var dataToPost = "SEQTEXT=" + strSeq + "&PTYPE=" + strType + "&EVALUE=" + e_val + "&FORMATOUT=" + intFormat;
		
		StartProcess("Autoantigen blast is being processed. Please wait ...");
		disableSubmit();
		
		// change the boolean value if necessary
		objHttp_Antigen.open('post', blastUrl, true);
		objHttp_Antigen.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); 
		objHttp_Antigen.onreadystatechange = retrieveBlastResult;
		objHttp_Antigen.send(dataToPost);
		return false;
	}

	/*
	*	multiple sequence alignment - autoantigen family
	*	blast query sequence against database, determine closest family, clustalw 
	*	using method - GET
	*/
	function executeAntigenAlign(strSeq, strPType, evalue) {
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var alignUrl = "http://discovery.imb.uq.edu.au/cgi-bin/AlignAntigenFamily.cgi?SEQTEXT=";
		alignUrl +=  strSeq + "&PTYPE=" + strPType + "&EVALUE=" + evalue;
		
		StartProcess("Autoantigen family alignment is being processed. Please wait...");
		disableSubmit();
		
		objHttp_Antigen.open('GET', alignUrl, true);
		objHttp_Antigen.onreadystatechange = retrieveAlignmentResult;
		objHttp_Antigen.send(null);
	}
	
	/*
	*	multiple sequence alignment - autoantigen family
	*	blast query sequence against database, determine closest family, clustalw 
	*	using method - Post
	*/
	function executeAntigenAlign_Post(strSeq, strPType, evalue) {
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return false;
		}
		
		var alignUrl = "http://discovery.imb.uq.edu.au/cgi-bin/AlignAntigenFamily.cgi"; 
		var dataToPost = "SEQTEXT=" + strSeq + "&PTYPE=" + strPType + "&EVALUE=" + evalue;
		
		StartProcess("Autoantigen family alignment is being processed. Please wait...");
		disableSubmit();
		
		objHttp_Antigen.open('post', alignUrl, true);
		objHttp_Antigen.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); 
		objHttp_Antigen.onreadystatechange = retrieveAlignmentResult;
		objHttp_Antigen.send(dataToPost);
		return false;
	}
	
	/* **************************************************
	* called from within search output - javascript
	* change default parameters if necessary here
	**************************************************** */
	function TCellByRankpep(strID) {
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var rankpepUrl = "http://discovery.imb.uq.edu.au/cgi-bin/RankpepPredict.cgi";
		var strParams = "MHC=1&matrixi=11mer_H2_Db.pwp";
		strParams += "&tfaln=tfa";
		strParams += "&SEQID=" + strID;
		strParams += "&option=b&percentage=2";
		strParams += "&cutonly=0&model=one&immune=0&cvalue=0.5&wt_low=0.00&wt_high=9999.00&var=1";
		myId = strID;
		
		StartSubProcess("TCell Epitope Rankpep prediction is being processed. Please wait...", strID);
		
		/* change the boolean value if necessary */
		//objHttp_Antigen.open('POST', rankpepUrl, false);		
		objHttp_Antigen.open('POST', rankpepUrl, true);		
		objHttp_Antigen.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
		
		/* comment the following line if necessary for asynchronous behavriour */
		objHttp_Antigen.onreadystatechange = retrieveTcellResult;
		objHttp_Antigen.send(strParams);	
		
		/* comment out the following line if necessary */
		//retrieveTcellResult();
		//return false;
	}
	
	/* ******************************************
	* call from within the BCell form - post
	******************************************** */
	function BepiPredBCellPrediction(strForm) {
			
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var bcellUrl = "http://discovery.imb.uq.edu.au/cgi-bin/BepiPredict.cgi";
		var frmBepiPred = document.forms[strForm];
		var strParams = "SEQPASTE=" + trim(frmBepiPred.SEQPASTE.value);
		strParams += "&threshold=" + frmBepiPred.threshold.value;
		
		StartProcess("BCell BepiPred prediction is being processed. Please wait...");
		disableSubmit();
		
		// change the boolean value if necessary
		objHttp_Antigen.open('POST', bcellUrl, true);
		objHttp_Antigen.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
				
		//un-comment the following line if necessary for asynchronous behavriour
		objHttp_Antigen.onreadystatechange = retrieveBepiPredResult;
		objHttp_Antigen.send(strParams);	
		
		// comment out the following line if necessary
		//retrieveBepiPredResult();
	}
	
	/*
	* called from within search output - BCell link, javascript
	*/
	function BCellByBepiPred(strID) {
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		myId = strID;
		var bcellUrl = "http://discovery.imb.uq.edu.au/cgi-bin/BepiPredict.cgi";
		var strParams = "SEQID=" + strID;
		strParams += "&threshold=0.35";
		
		StartSubProcess("BCell BepiPred prediction is being processed. Please wait...", strID);
		
		/* change the boolean value if necessary */
		//objHttp_Antigen.open('POST', bcellUrl, false);
		objHttp_Antigen.open('POST', bcellUrl, true);
		objHttp_Antigen.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
		
		/* un-comment the following line if necessary for asynchronous behavriour */
		objHttp_Antigen.onreadystatechange = retrieveBcellResult;
		objHttp_Antigen.send(strParams);	
		
		/* comment out the following line if necessary */
		//retrieveBcellResult();
		//return false;
	}

	/* **********************************************************
	*	send query sequence for T-Cell epitope prediction
	*	connect to http prediction server RANKPEP
	*	submit query sequence and retrieve prediction result
	************************************************************* */
	function RankpepTCellPrediction(strForm) {
		
		//params:
		//	0. MHC => 1/2 [default = 1]
		//	1. matrixi	[MHC I - matrix file]
		//	1. matrixii [MHC II - matrix file]
		//	2. tfaln  ["tfa"] => fasta file for query sequence
		//	2. tfaln  ["aln"] => alignment file for prediction
		//	3. sequence [fasta sequence >SEQID asdfafdafdasdfasdf]
		//	4. option -> b percentage = [2,3,4, ..., 10, 15, 20]
		//	4. option -> a number = [5, 10, 15, 20, 30, 990]
		//	5. cutonly => 0/1 [default = 0]
		//	6. model => one/two/three [default = one]
		//	7. immune => 0/1 [default = 0]
		//	8. cvalue => 0.5/0.0/1.0 [default = 0.5]
		//	9. wt-low => default 0.0
		//	10. wt-high => default 9999
		//	11. var => 1.0 [0.0-4.3] default 1.0
		//	multipart/form-data
		//
		
		if (!objHttp_Antigen) {
			objHttp_Antigen = getHttpRequest();
		}
		
		if (!objHttp_Antigen) {
			alert ("Your browser does not support XMLHttpRequest!");
			return;
		}
		
		var rankpepUrl = "http://discovery.imb.uq.edu.au/cgi-bin/RankpepPredict.cgi";
		var frmRankpep = document.forms[strForm];
		var strParams = "";
		var strMHC = getCheckedMHC(strForm);
		var strMatrix = null;
		var optFilter = getCheckedFilterOption(strForm);
		
		if (strMHC == "1") {
			strMatrix = "&matrixi=" + frmRankpep.matrixi.value;
		}
		
		if (strMHC == "2") {
			strMatrix = "&matrixii=" + frmRankpep.matrixii.value;
		}
		
		strMHC = "MHC=" + strMHC;
		strParams += strMHC;
		strParams += strMatrix;
		strParams += "&tfaln=tfa";
		strParams += "&sequence=" + trim(frmRankpep.sequence.value);
		
		if (optFilter == "a") {
			strParams += "&option=a&number=" + frmRankpep.number.value;
		}
		else if (optFilter == "b") {
			strParams += "&option=b&percentage=" + frmRankpep.percentage.value;
		}
		
		strParams += "&cutonly=0&model=one&immune=0&cvalue=0.5&wt_low=0.00&wt_high=9999.00&var=1";
		
		StartProcess("TCell Epitope Rankpep prediction is being processed. Please wait...");
		disableSubmit();
				
		objHttp_Antigen.open('POST', rankpepUrl, true);
		objHttp_Antigen.setRequestHeader('content-Type', 'application/x-www-form-urlencoded');
		objHttp_Antigen.onreadystatechange = retrieveRankpepResult;
		objHttp_Antigen.send(strParams);
	}
	
	function retrieveRankpepResult() {
		var result = null;
		var frameOutput = document.getElementById('ifr_rankpep_output');
		var urlStart = -1;
		var urlEnd = -1;
		
		if (objHttp_Antigen.readyState == 4) {
			EndProcess("Autoantigen T-Cell Rankpep prediction done!");
			result = objHttp_Antigen.responseText;
						
			if (result.match("<URL>")) {
				urlStart = result.indexOf("<URL>");
				urlStart += 5;
				urlEnd = result.indexOf("</URL>");
				frameOutput.src = result.substring(urlStart, urlEnd);
				resetError("&nbsp;");
				showSection('rankpep_result');
			}
			else if (result.match("<INVALID>")) {
				msgstart = result.indexOf("<INVALID>");
				msgstart += 9;
				msgend = result.indexOf("</INVALID>");
				setError("INVALID RANKPEP: " + result.substring(msgstart, msgend));				
			}
			else if (result.match("<ERROR>")) {
				msgstart = result.indexOf("<ERROR>");
				msgstart += 7;
				msgend = result.indexOf("</ERROR>");
				setError("RANKPEP ERROR: " + result.substring(msgstart, msgend));
			}
			else {
				setError("The RANKPEP server does not return any valid result.");
			}
		}
	}
	
	function retrieveTcellResult() {
		var result = null;
		var frameOutput = document.getElementById('ifr_rankpep_output');
		var urlStart = -1;
		var urlEnd = -1;
		
		if (objHttp_Antigen.readyState == 4) {
			EndSubProcess("Autoantigen T-Cell Rankpep prediction done!", myId);
			result = objHttp_Antigen.responseText;
						
			if (result.match("<URL>")) {
				urlStart = result.indexOf("<URL>");
				urlStart += 5;
				urlEnd = result.indexOf("</URL>");
				frameOutput.src = result.substring(urlStart, urlEnd);
				resetProcessError("&nbsp;", myId);
				showSection('rankpep_result');
			}
			else if (result.match("<INVALID>")) {
				msgstart = result.indexOf("<INVALID>");
				msgstart += 9;
				msgend = result.indexOf("</INVALID>");
				setProcessError("INVALID RANKPEP: " + result.substring(msgstart, msgend), myId);				
			}
			else if (result.match("<ERROR>")) {
				msgstart = result.indexOf("<ERROR>");
				msgstart += 7;
				msgend = result.indexOf("</ERROR>");
				setProcessError("RANKPEP ERROR: " + result.substring(msgstart, msgend), myId);
			}
			else {
				setProcessError("The RANKPEP server does not return any valid result.", myId);
			}
		}
	}
	
	function retrieveBepiPredResult() {
		var result = null;
		var frameOutput = document.getElementById('ifr_bepipred_output');
		var urlStart = -1;
		var urlEnd = -1;
		
		if (objHttp_Antigen.readyState == 4) {
			EndProcess("Autoantigen B-Cell Epitope prediction done!");			
			result = objHttp_Antigen.responseText;
			
			if (result.match("<URL>")) {
				urlStart = result.indexOf("<URL>");
				urlStart += 5;
				urlEnd = result.indexOf("</URL>");
				frameOutput.src = result.substring(urlStart, urlEnd);
				resetError("&nbsp;");
				showSection('bepipred_result');
			}
			else if (result.match("<INVALID>")) {
				msgstart = result.indexOf("<INVALID>");
				msgstart += 9;
				msgend = result.indexOf("</INVALID>");
				setError("INVALID BepiPred: " + result.substring(msgstart, msgend));				
			}
			else if (result.match("<ERROR>")) {
				msgstart = result.indexOf("<ERROR>");
				msgstart += 7;
				msgend = result.indexOf("</ERROR>");
				//alert ("SEARCH ERROR: " + result.substring(msgstart, msgend));
				setError("BepiPred ERROR: " + result.substring(msgstart, msgend));
			}
			else {
				setError("The BepiPred server did not return any valid result.");
			}
		}
	}
	
	function retrieveBcellResult() {
		var result = null;
		var frameOutput = document.getElementById('ifr_bepipred_output');
		var urlStart = -1;
		var urlEnd = -1;
		
		if (objHttp_Antigen.readyState == 4) {
			EndSubProcess("Autoantigen B-Cell Epitope prediction done!", myId);			
			result = objHttp_Antigen.responseText;
			
			if (result.match("<URL>")) {
				urlStart = result.indexOf("<URL>");
				urlStart += 5;
				urlEnd = result.indexOf("</URL>");
				frameOutput.src = result.substring(urlStart, urlEnd);
				resetProcessError("&nbsp;", myId);
				showSection('bepipred_result');
			}
			else if (result.match("<INVALID>")) {
				msgstart = result.indexOf("<INVALID>");
				msgstart += 9;
				msgend = result.indexOf("</INVALID>");
				setProcessError("INVALID BepiPred: " + result.substring(msgstart, msgend), myId);				
			}
			else if (result.match("<ERROR>")) {
				msgstart = result.indexOf("<ERROR>");
				msgstart += 7;
				msgend = result.indexOf("</ERROR>");
				setProcessError("BepiPred ERROR: " + result.substring(msgstart, msgend), myId);
			}
			else {
				setProcessError("The BepiPred server did not return any valid result.", myId);
			}
		}
	}
	
	function retrieveSearchResult() {
		var result = null;
		var urlstart = null;
		var urlend = null;
		var msgstart = null;
		var msgend = null;
		var frameOutput = document.getElementById('Antigen_Search_Out');
		var resURL = null;
		
		if (objHttp_Antigen.readyState == 4) {
			EndProcess("Autoantigen search done!");
			result = objHttp_Antigen.responseText;
			
			// check if search result returns with url
			if (result.match("<URL>")) {
				urlstart = result.indexOf("<URL>");
				urlstart += 5;
				urlend = result.indexOf("</URL>");
				resURL = result.substring(urlstart, urlend);
				//window.open(resURL, "AutoantigenSearchResult", "left=20, top=20, width=800, height=600,toolbar=1, resizable=1, scrollbars=1, status=1");
				frameOutput.src = resURL;
				resetError("&nbsp;");
				showSection('search_result');
			}
			else if (result.match("<INVALID>")) {
				msgstart = result.indexOf("<INVALID>");
				msgstart += 9;
				msgend = result.indexOf("</INVALID>");
				setError("INVALID SEARCH: " + result.substring(msgstart, msgend));				
			}
			else if (result.match("<ERROR>")) {
				msgstart = result.indexOf("<ERROR>");
				msgstart += 7;
				msgend = result.indexOf("</ERROR>");
				//alert ("SEARCH ERROR: " + result.substring(msgstart, msgend));
				setError("SEARCH ERROR: " + result.substring(msgstart, msgend));
			}
			else {
				setError("Your keyword search does not return any match.");
			}
		}
	}
		
	function retrieveBlastResult() {
		var result = null;
		var divResult = document.getElementById('blast_result');
		var frameOutput = document.getElementById('Antigen_Blast_Out');
		var msgStart = null;
		var msgEnd = null;
		
		//var msg_wait = document.getElementById('msg_wait');
		//var msg_complete = document.getElementById('msg_complete');
			
		if (objHttp_Antigen.readyState == 4) {
			EndProcess("Autoantigen blast done!");	
			result = objHttp_Antigen.responseText;

			if (result.match("<URL>")) {
				var urlstart = result.indexOf("<URL>");
				urlstart += 5;
				var urlstop = result.indexOf("</URL>");
			
				frameOutput.src = result.substring(urlstart, urlstop);
				//window.open(result.substring(urlstart, urlstop), "AutoantigenBlastResult");
				resetError("&nbsp;");
				showSection('blast_result');
			}
			else if (result.match("<ERROR>")) {
				msgStart = result.indexOf("<ERROR>");
				msgStart += 7;
				msgEnd = result.indexOf("</ERROR>");
				//alert(result.substring(msgStart, msgEnd));
				setError(result.substring(msgStart, msgEnd));				
			}
			else if (result.match("<INVALID>")) {
				msgStart = result.indexOf("<INVALID>");
				msgStart += 9;
				msgEnd = result.indexOf("</INVALID>");
				//alert(result.substring(msgStart, msgEnd));
				setError(result.substring(msgStart, msgEnd));
			}
			else if (result.match("<DOWN>")) {
				setError("The system is down. Please try again later.");
			}
			else {
				setError("response status = " + objHttp_Antigen.status);
			}
		}
	}
	
	function retrieveAlignmentResult() {
		var result = null;
		var divResult = document.getElementById('align_result');
		var frameOutput = document.getElementById('Antigen_Align_Out');
		var msgStart = null;
		var msgEnd = null;
		
		if (objHttp_Antigen.readyState == 4) {
			EndProcess("Autoantigen family alignment done!");
			result = objHttp_Antigen.responseText;
			
			if (result.match("<URL>")) {
				var urlstart = result.indexOf("<URL>");
				urlstart += 5;
				var urlstop = result.indexOf("</URL>");
				frameOutput.src = result.substring(urlstart, urlstop);
				resetError("&nbsp;");
				showSection('align_result');
			}
			else if (result.match("<ERROR>")) {
				msgStart = result.indexOf("<ERROR>");
				msgStart += 7;
				msgEnd = result.indexOf("</ERROR>");
				setError(result.substring(msgStart, msgEnd));
			}
			else if (result.match("<INVALID>")) {
				msgStart = result.indexOf("<INVALID>");
				msgStart += 9;
				msgEnd = result.indexOf("</INVALID>");
				setError(result.substring(msgStart, msgEnd));
			}
			else if (result.match("<DOWN>")) {
				setError("The system is down. Please try again later.");
			}
			else {
				setError("response status = " + objHttp_Antigen.status);
			}
		}
	}

	/* 
	//Autoantigen database blast Web form input checking etc
	//check if user has entered sequence etc - using GET
	*/
	function check_antigen_blast(strForm) {
		var warning_empty = "Please enter valid query sequence in the textarea.";
		var debugging = "The system is undergoing major maintenance and upgrade. Please check back later.";
		var testing = "Please be advised the Autoantigen Web Blast is currently being tested.";
		var myForm = document.forms[strForm];	
		/* 
		check if text area [ seq_text ] is empty more testing may be done to check actual
		sequence entered  
		*/
	
		var strSeq = myForm.SEQTEXT.value;
		var strEvalue = myForm.EVALUE.value;
		
		//var strPType = getCheckedType(strForm);
		var strPType = "blastp";
		
		strEvalue = trim(strEvalue);
		strSeq = trim(strSeq);
		if (!strSeq) {
			setError("Please enter valid sequence!");
			return false;
		}	
	
		if (!myForm.FORMATOUT.value) {
			setError("Please select output format option!");
			return false;
		}
	
		if (!strEvalue || isNaN(strEvalue)) {
			setError("Please enter a valid expectation value.");
			return false;
		}
	
		if (strPType == "blastp") {
			if (!isValidProtein(strSeq)) {
				setError("Invalid protein sequence entered!");
				return false;
			}
		}
	
		if (strPType == "blastx") {
			if (!isValidDNA(strSeq)) {
				setError("Invalid DNA sequence entered!");
				return false;
			}
		}
		
		strSeq = myForm.SEQTEXT.value;
		strSeq = trim(strSeq);
		
		if (!isSingleSeq(strSeq, 10000)) {
			return false;
		}
		
		// execute server process
		resetError("&nbsp;");
		executeAntigenBlast(strSeq, strPType, strEvalue, myForm.FORMATOUT.value);
		return false;
	}
	
	/* 
	//Autoantigen database blast Web form input checking etc
	//check if user has entered sequence etc - using POST
	*/
	function post_antigen_blast(strForm) {
		var warning_empty = "Please enter valid query sequence in the textarea.";
		var debugging = "The system is undergoing major maintenance and upgrade. Please check back later.";
		var testing = "Please be advised the Autoantigen Web Blast is currently being tested.";
		var myForm = document.forms[strForm];	
		/* 
		check if text area [ seq_text ] is empty more testing may be done to check actual
		sequence entered  
		*/
	
		var strSeq = myForm.SEQTEXT.value;
		var strEvalue = myForm.EVALUE.value;
		
		//var strPType = getCheckedType(strForm);
		var strPType = "blastp";
		
		strEvalue = trim(strEvalue);
		strSeq = trim(strSeq);
		if (!strSeq) {
			setError("Please enter valid sequence!");
			return false;
		}	
	
		if (!myForm.FORMATOUT.value) {
			setError("Please select output format option!");
			return false;
		}
	
		if (!strEvalue || isNaN(strEvalue)) {
			setError("Please enter a valid expectation value.");
			return false;
		}
	
		if (strPType == "blastp") {
			if (!isValidProtein(strSeq)) {
				setError("Invalid protein sequence entered!");
				return false;
			}
		}
	
		if (strPType == "blastx") {
			if (!isValidDNA(strSeq)) {
				setError("Invalid DNA sequence entered!");
				return false;
			}
		}
		
		strSeq = myForm.SEQTEXT.value;
		strSeq = trim(strSeq);
		
		if (!isSingleSeq(strSeq, 10000)) {
			return false;
		}
		
		var seqId = getSeqId(strSeq);
		var seq = getSequence(strSeq);
		
		// execute server process
		resetError("&nbsp;");
		executeAntigenBlast_Post(">"+seqId + " " + seq, strPType, strEvalue, myForm.FORMATOUT.value);
		return false;
	}
	
	/*
	*	using GET 
	*/
	function check_antigen_align(strForm) {
		var myForm = document.forms[strForm];	
		var strSeq = myForm.SEQTEXT.value;
		var evalue = myForm.EVALUE.value;
		var strPType = "blastp";
		
		strSeq = trim(strSeq);
		if (!strSeq) {
			setError("Please enter valid sequence!");
			return false;
		}	
		
		if (strPType == "blastp") {
			if (!isValidProtein(strSeq)) {
				setError("Invalid protein sequence entered!");
				return false;
			}
		}
	
		if (strPType == "blastx") {
			if (!isValidDNA(strSeq)) {
				setError("Invalid DNA sequence entered!");
				return false;
			}
		}
		
		strSeq = myForm.SEQTEXT.value;
		strSeq = trim(strSeq);
		
		if (!isSingleSeq(strSeq, 10000)) {
			return false;
		}
		
		// execute server process
		resetError("&nbsp;");
		executeAntigenAlign(strSeq, strPType, evalue);
		return false;
	}

	/*
	*	using POST 
	*/
	function post_antigen_align(strForm) {
		var myForm = document.forms[strForm];	
		var strSeq = myForm.SEQTEXT.value;
		var evalue = myForm.EVALUE.value;
		var strPType = "blastp";
		
		strSeq = trim(strSeq);
		if (!strSeq) {
			setError("Please enter valid sequence!");
			return false;
		}	
		
		if (strPType == "blastp") {
			if (!isValidProtein(strSeq)) {
				setError("Invalid protein sequence entered!");
				return false;
			}
		}
	
		if (strPType == "blastx") {
			if (!isValidDNA(strSeq)) {
				setError("Invalid DNA sequence entered!");
				return false;
			}
		}
		
		strSeq = myForm.SEQTEXT.value;
		strSeq = trim(strSeq);
		
		if (!isSingleSeq(strSeq, 10000)) {
			return false;
		}
		
		var seqID = getSeqId(strSeq);
		var seq = getSequence(strSeq);
		
		// execute server process
		resetError("&nbsp;");
		executeAntigenAlign_Post(">" + seqID + " " + seq, strPType, evalue);
		return false;
	}

	//antigen keyword search, input checking, server side processing
	function check_antigen_search (strForm) {		
		var frmSearch = document.forms[strForm];
		var strKeywords = frmSearch.KEYWORD_AADB.value;
		
		strKeywords = trim(strKeywords);
		
		var strField = frmSearch.FIELD_AADB.value;
		var strOp = null;
		var radioOp = frmSearch.SEARCH_OPT;
		var i = 0;
		
		for (i = 0; i < radioOp.length; i++) {
			if (radioOp[i].checked) {
				strOp = radioOp[i].value;
			}
		}
		
		if (!strOp) {
			strOp = "OR";
		}
		
		if (strKeywords == "") {
			strKeywords = "EMPTY";
		}
		else {
			if (!isDescValid(strKeywords)) {
				setError("Please enter valid keyword(s).");
				return false;
			}
		}
					
		resetError("&nbsp;");
		executeAntigenSearch(strKeywords, strOp, strField);
		return false;
	}
	
	/*
	*	check user input before submitting form - bepipred
	*/
	function check_bepipred_input(strForm) {
		var frmBepipred = document.forms[strForm];
		var strSeq = frmBepipred.SEQPASTE.value;
		strSeq = trim(strSeq);
		
		if (!strSeq) {
			setError("Please enter valid protein sequence(s).");
			return false;
		}
		else if (!isValidProtein(strSeq)) {
			setError("Invalid protein sequence entered!");
			return false;
		}
		
		resetError("&nbsp;");
		BepiPredBCellPrediction(strForm);
		return false;
	}
	
	/*
	* Submit MULTIPRED job
	*/
	function submit_multipred_job(strForm) {
		//alert("Testing ...");
		var multipred_url = "http://research.i2r.a-star.edu.sg/multipred/cgi/";
		var allOk = check_multipred_seq(strForm);
		
		if (allOk) {
			var myForm = document.forms[strForm];
			var strSeq = myForm.SEQ.value;
			var dbmetd = getMultipredMethod(strForm);
			var dbclass = getMultipredClass(strForm);
			var metdname = (dbmetd == "HMM") ? "Hidden Markov Model" : "Artificial Neural Network";
			var seqtype = "prot";
			var cgi_app = (dbclass == "classIIDR") ? "runpredictDR.pl" : "runpredict.pl";
			var FILENAME = getSeqId(strSeq);
			var SEQ = getSequence(strSeq);			
			multipred_url += cgi_app + "?SEQ=" + SEQ;
			multipred_url += "&SEQTYPE=" + seqtype;
			multipred_url += "&FILENAME=" + FILENAME;
			multipred_url += "&metdname=" + metdname;
			multipred_url += "&dbclass=" + dbclass;
			multipred_url += "&dbmetd=" + dbmetd;

			disableSubmit();
			
			window.open(multipred_url);
			return false;
		}
		
		return false;
	}
	
	/*
		This is called from the embedded form in the AADB record
	*/
	function embedded_multipred_job(strForm, strID, strSeq) {
		var multipred_url = "http://research.i2r.a-star.edu.sg/multipred/cgi/";
		
		//var allOk = check_multipred_seq(strForm);
		
		var myForm = document.forms[strForm];
		var dbclass = getMultipredClass(strForm);
		var dbmetd = getMultipredMethodOption(strForm);
		
		var metdname = (dbmetd == "HMM") ? "Hidden Markov Model" : "Artificial Neural Network";
		var seqtype = "prot";
		var cgi_app = (dbclass == "classIIDR") ? "runpredictDR.pl" : "runpredict.pl";
		var FILENAME = strID;
		var SEQ = strSeq;
						
		multipred_url += cgi_app + "?SEQ=" + SEQ;
		multipred_url += "&SEQTYPE=" + seqtype;
		multipred_url += "&FILENAME=" + FILENAME;
		multipred_url += "&metdname=" + metdname;
		multipred_url += "&dbclass=" + dbclass;
		multipred_url += "&dbmetd=" + dbmetd;

		disableSubmit();
		window.open(multipred_url);
		return false;
	}
	
	/*
	* Submit PREDTAP job
	*/
	function submit_predtap_job(strForm) {
		//alert("Testing ...");
		var predtap_url = "http://antigen.i2r.a-star.edu.sg/predTAP/cgi/runpredict.pl";
		var allOk = check_predtap_seq(strForm);
		
		if (allOk) {
			var myForm = document.forms[strForm];
			var strSeq = myForm.SEQ.value;
			var METD = getPredtapMethod(strForm);
			var seqtype = "prot";
			var NAME = getSeqId(strSeq);
			var SEQ = getSequence(strSeq);			
			
			predtap_url += "?METD=" + METD;
			predtap_url += "&SEQ=" + SEQ;
			predtap_url += "&SEQTYPE=" + seqtype;
			predtap_url += "&NAME=" + NAME;

			disableSubmit();
			
			window.open(predtap_url);
			return false;
		}
		
		return false;
	}

	/*
		This is called from the embedded form in the AADB record
	*/
	function embedded_predtap_job(strForm, strID, strSeq) {
		var predtap_url = "http://antigen.i2r.a-star.edu.sg/predTAP/cgi/runpredict.pl";
		var myForm = document.forms[strForm];
		var METD = getPredtapMethod(strForm);
		var seqtype = "prot";
		var NAME = strID;
		var SEQ = strSeq;			
			
		predtap_url += "?METD=" + METD;
		predtap_url += "&SEQ=" + SEQ;
		predtap_url += "&SEQTYPE=" + seqtype;
		predtap_url += "&NAME=" + NAME;

		disableSubmitOne();
			
		window.open(predtap_url);
		return false;
	}
	
	/*
		sequence for MULTIPRED 
		1. protein sequence only
		2. Single sequence only
		3. maximum length = 2000!
	*/
	function check_multipred_seq(strForm) {
		var frmMultipred = document.forms[strForm];
		
		disableSubmit();
		
		if (!frmMultipred) {
			return false;
		}
		
		var strSeq = frmMultipred.SEQ.value;
		strSeq = trim(strSeq);
		
		if (!strSeq) {
			setError("Sequence must not be empty!");
			return false;
		}
		
		if (!isValidProtein(strSeq)) {
			setError("The entered sequence must be protein sequence!");
			return false;
		}
		
		strSeq =  frmMultipred.SEQ.value;
		
		if (!isSingleSeq(strSeq, 2000)) {
			return false;
		}
		
		enableSubmit();
		resetError("&nbsp;");
		return true;
	}
	
	/*
		sequence for PREDTAP 
		1. protein sequence only
		2. Single sequence only
		3. maximum length = 2000!
	*/
	function check_predtap_seq(strForm) {
		var frmPredtap = document.forms[strForm];
		
		disableSubmit();
		
		if (!frmPredtap) {
			return false;
		}
		
		var strSeq = frmPredtap.SEQ.value;
		strSeq = trim(strSeq);
		
		if (!strSeq) {
			setError("Sequence must not be empty!");
			return false;
		}
		
		if (!isValidProtein(strSeq)) {
			setError("The entered sequence must be protein sequence!");
			return false;
		}
		
		strSeq =  frmPredtap.SEQ.value;
		
		if (!isSingleSeq(strSeq, 2000)) {
			return false;
		}
		
		enableSubmit();
		resetError("&nbsp;");
		return true;
	}

	function getSeqId(strSeq) {
		strSeq = trim(strSeq);
		if (!strSeq.match(/>\s*\w+\s+\w+/)) {
			return "ID_Unknown";
		}
		strSeq = strSeq.replace(/>\s+/, ">");
		return strSeq.substring(1, strSeq.indexOf(" "));
	}
	
	function getSequence(strSeq) {
		if (strSeq.match(/>\s*\w+\s+\w+/)) {
			strSeq = strSeq.replace(/>\s*\w+\s+/, "");
			return stripWhite(strSeq);
		}
		else {
			return stripWhite(strSeq);
		}
	}
	
	/*
	* 	check user input before submitting form - rankpep
	*/
	function check_rankpep_input(strForm) {
		var frmRankpep = document.forms[strForm];
		var intType = getCheckedMHC(strForm);
		var strFilter = getCheckedFilterOption(strForm);
		var matrixOpt = null;
		var filterOpt = null;
		
		switch (intType) {
			case "1": 
				matrixOpt = frmRankpep.matrixi.value;
				break;
			case "2":
				matrixOpt = frmRankpep.matrixii.value;
				break;
			default:
				setError("The selected option is not supported.");
				return false;
		}
		
		if (!matrixOpt) {
			setError("Please select valid score matrix for prediction.");
			return false;
		} 
		else {
			resetError("&nbsp;");
		}
		
		switch(strFilter) {
			case "a":
				filterOpt = frmRankpep.number.value;
				break;
				
			case "b":
				filterOpt = frmRankpep.percentage.value;
				break;
			default:
				setError("Please select valid result filter.");
				return false;
		}
		
		if (!filterOpt) {
			setError("Please select valid result filter for prediction output.");
			return false;
		}
		else {
			resetError("&nbsp;");
		}
		
		var strSeq = frmRankpep.sequence.value;
		strSeq = trim(strSeq);
		
		if (!strSeq) {
			setError("Please enter valid protein sequence(s).");
			return false;
		}
		else if (!isValidProtein(strSeq)) {
			setError("Invalid protein sequence entered!");
			return false;
		}
		
		/*
		*	all went well...
		*/
		resetError("&nbsp;");
		RankpepTCellPrediction(strForm);
		return false;
	}
		
	function changeMatrixOptions() {
		var tcellForm = document.forms['rankpep_tcell_frm'];
		var listTypeI = tcellForm.matrixi;
		var listTypeII = tcellForm.matrixii;
		var intType = getCheckedMHC('rankpep_tcell_frm');
		
		/*
		use switch and case?
		*/
		
		if (intType == 1) {
			listTypeI.disabled = false;
			listTypeII.disabled = true;
		}
		
		if (intType == 2) {
			listTypeI.disabled = true;
			listTypeII.disabled = false;
		}
		return true;
	}
	
	function changeFilterOption() {
		var tcellForm = document.forms['rankpep_tcell_frm'];
		var filterOptI = tcellForm.percentage;
		var filterOptII = tcellForm.number;
		var strOpt = getCheckedFilterOption('rankpep_tcell_frm');
		
		/*
		use switch and case?
		*/
		if (strOpt == "a") {	/* number option */
			filterOptI.disabled = true;
			filterOptII.disabled = false;
		}
		
		if (strOpt == "b") {
			filterOptI.disabled = false;
			filterOptII.disabled = true;
		}
		
		return true;
	}
	
	/*
	* check keyword entry for search
	*/
	function check_entry(strId) {
		var inputField = document.getElementById(strId);
		var strInput = inputField.value;
		
		strInput = trim(strInput);
		
		if (strInput == "") {
			resetError("&nbsp;");
			return true;
		}
		
		if (!isDescValid(strInput)) {
			setError("Please enter valid keyword(s).");
		}
		else {
			resetError("&nbsp;");
		}
		return true;
	}
	
	/*
	* check sequence entered for RANKPEP
	*/
	function check_rankpep_seq(strForm) {
		var frmQuery = document.forms[strForm];
		var strInput = frmQuery.sequence.value;
		strInput = trim(strInput);
		
		if (!strInput) {
			setError("Please enter valid protein sequence(s).");
		}
		else if (!isValidProtein(strInput)) {
			setError("Invalid protein sequence entered!");
		}
		else {
			resetError("&nbsp;");
		}
		return true;
	}
	
	/*
	*	check sequence entered for BEPIPRED
	*/
	function check_bepipred_seq(strForm) {
		var frmQuery = document.forms[strForm];
		var strInput = frmQuery.SEQPASTE.value;
		strInput = trim(strInput);
		
		if (!strInput) {
			setError("Please enter valid protein sequence(s).");
		}
		else if (!isValidProtein(strInput)) {
			setError("Invalid protein sequence entered!");
		}
		else {
			resetError("&nbsp;");
		}
	}
	
	/*
	*	check sequence entered for blast form
	*/
	function check_sequence(strForm) {
		var frmQuery = document.forms[strForm];
		var inputField = frmQuery.SEQTEXT;
		var strInput = inputField.value;
		strInput = trim(strInput);
		
		if (!strInput) {
			setError("Please enter valid sequence(s).");
			return false;
		}
		else if (!isValidProtein(strInput)) {
			setError("Invalid protein sequence entered!");
			return false;
		}		
		
		strInput = inputField.value;
		if (!isSingleSeq(strInput, 10000)) {
			return false;
		}
		resetError("&nbsp;");	
		return true;
	}
	
	function getCheckedType(strForm) {
		var myForm = document.forms[strForm];
		var myRadios = myForm.PTYPE;

		var i = 0;
	
		for (i = 0; i < myRadios.length; i++) {
			if (myRadios[i].checked) {
				return myRadios[i].value;
			}
		}
		return -1;
	}
	
	/* **********************************************************************************
	* The following a few methods/functions are for handling Multipred/PredTAP form submission
	************************************************************************************/
	function getMultipredMethod(strForm) {
		var myForm = document.forms[strForm];
		var myRadios = myForm.dbmetd;
		var i = 0;
	
		for (i = 0; i < myRadios.length; i++) {
			if (myRadios[i].checked) {
				return myRadios[i].value;
			}
		}
		return -1;
	}
	
	function getPredtapMethod(strForm) {
		var myForm = document.forms[strForm];
		var myRadios = myForm.METD;
		var i = 0;
	
		for (i = 0; i < myRadios.length; i++) {
			if (myRadios[i].checked) {
				return myRadios[i].value;
			}
		}
		return "UNKNOWN";
	}
	
	function getMultipredMethodOption(strForm) {
		var myForm = document.forms[strForm];
		var myOptions = myForm.dbmetd;
		var optId = myOptions.selectedIndex;
		
		if (optId != -1) {
			return myOptions.options[optId].value;
		}
		else {
			return myOptions.options[0].value;
		}
	}
	
	function getMultipredClass(strForm) {
		var myForm = document.forms[strForm];
		var myOptions = myForm.dbclass;
		var optId = myOptions.selectedIndex;
		
		if (optId != -1) {
			return myOptions.options[optId].value;
		}
		else {
			return myOptions.options[0].value;
		}
	}
	
	/*
	* 	for Rankpep/BepiPred
	*	retrieve the class of MHC selected: 1 or 2 
	*/
	function getCheckedMHC(strForm) {
		var myForm = document.forms[strForm];
		var myRadios = myForm.MHC;
		var i = 0;
				
		for (i = 0; i < myRadios.length; i++) {
			if (myRadios[i].checked) {
				return myRadios[i].value;
			}
		}
		return -1;
	}
	
	function getCheckedFilterOption(strForm) {
		var myForm = document.forms[strForm];
		var myRadios = myForm.option;
		var i = 0;
		
		for (i = 0; i < myRadios.length; i++) {
			if (myRadios[i].checked) {
				return myRadios[i].value;
			}
		}
		
		return "unknown";
	}
	
	function isValidText(strText) {
		strText = trim(strText);
		if (!strText) {
			return false;
		}
	
		if (isValidProtein(strText)) {
			return true;
		}
	
		if (isValidDNA(strText)) {
			return true;
		}
		return false;
	}

	function trim(myStr) {
		return myStr.replace(/^\s+|\s+$/g, "");
	}

	function stripWhite(myStr) {
		return myStr.replace(/\s+/g, "");
	}

	/* implementation not complete */
	function isValidProtein(strSeq) {
		// pattern to check = /[^acdefghiklmnpqrstvwyx]/i
		if (!strSeq.match(/>/)) {
			strSeq = stripWhite(strSeq);
			if (strSeq.match(/[^acdefghiklmnpqrstvwyx]/i)) {
				return false;
			}
		}
		else {
			// sequenc has id line 
			strSeq = strSeq.replace(/>\s*\w+\s+/g, "");
			strSeq = stripWhite(strSeq);		
			if (!strSeq) {
				return false;
			}
		
			if (strSeq.match(/[^acdefghiklmnpqrstvwyx]/i)) {
				return false;
			}
		}
		return true;
	}

	function isValidDNA(strSeq) {
		//pattern to check = /[^actgn]/i;
	
		if (!strSeq.match(/>/)) {
			strSeq = stripWhite(strSeq);
		
			if (strSeq == "") {
				return false;
			}
		
			if (strSeq.match(/[^actgn]/i)) {
				return false;
			}
		}
		else {
			// sequenc has id line 
			strSeq = strSeq.replace(/>\s*\w+\s+/g, "");
			strSeq = stripWhite(strSeq);		
		
			if (strSeq == "") {
				return false;
			}
		
			if (strSeq.match(/[^actgn]/i)) {
				return false;
			}
		}
		return true;
	}
	
	/*
	check if user entered a single, valid sequence
	*/
	function isSingleSeq(strSeq, intLength) {
		if (strSeq.match(/>\s*\w+\s+\w/)) {
			strSeq = strSeq.replace(/>\s*\w+\s+/, "");
			if (strSeq.match(/>\s*\w+/)) {
				setError("Invalid sequence entered. Please enter single sequence only!");
				return false;
			}

			if (limitExceeded(strSeq, intLength)) {
				return false; 
			}
		}
		else {
			strSeq = stripWhite(strSeq);
			if (limitExceeded(strSeq, intLength)) {
				return false;
			}
		}
		resetError("&nbsp;");
		return true;
	}

	function limitExceeded(strSeq, maxLen) {
		var minLen = 20;
		strSeq = stripWhite(strSeq);
		if (strSeq.length > maxLen) {
			setError("Maximum sequence length allowed = " + maxLen + "!");
			return true;
		}
		
		if (strSeq.length <= minLen) {
			setError("Minimum sequence length required = " + minLen + "!");
			return true;
		}
		return false;
	}
	
	/*
		check to see if a string is valid, i.e., contains word characters
	*/
	function isDescValid(strInput) {
		strInput = trim(strInput);
		var strClean = strInput.replace(/\W/g, "");
		
		// blank string?
		if (!strInput) {
			return false;
		}
		
		// none word character only?
		if (!strClean) {
			return false;
		}
		
		// number only?
		if (strClean.match(/^\d+$/)) {
			return false;
		}
		
		// under score only?
		if (strClean.match(/^_+$/)) {
			return false;
		}
		return true;
	}

	function reload_content(){
		//window.alert("The page will be refreshed ... ");
		window.location.replace("http://discovery.imb.uq.edu.au/Autoantigen.shtml");
	}
	
	//display the given [div], hide all others [div]
	function showSection(strId) {
		var divToShow = document.getElementById(strId);
		
		if (divToShow != null) {
			divToShow.style.display = "block";
		}
		
		var divToHide = null;
		var i = 0;
		
		/*
		* hide all the rest of the page sections/divs
		*/
		for (i = 0; i < Sections.length; i++) {
			if (strId != Sections[i]) {
				divToHide = document.getElementById(Sections[i]);
				if (divToHide != null) {
					divToHide.style.display = "none";
				}
			}
		}
	}
	
	function StartProcess(strMsg) {
		resetProcessMsg("&nbsp;");
		self.status = strMsg;
		document.body.style.cursor = "wait";
		setProcessMsg(strMsg);	
	}

	function EndProcess(strMsg) {
		self.status = strMsg;
		document.body.style.cursor = "auto";
		resetProcessMsg("&nbsp;");
	}
	
	function StartSubProcess(strMsg, strID) {
		resetSubProcessMsg("&nbsp;", strID);
		self.status = strMsg;
		document.body.style.cursor = "wait";
		setSubProcessMsg(strMsg, strID);
	}
	
	function EndSubProcess(strMsg, strID) {
		self.status = strMsg;
		document.body.style.cursor = "auto";
		resetSubProcessMsg(strMsg, strID);
	}
		
	function setError(strMsg) {
		var objErr = document.getElementById('process_err_msg');
		self.status = "Done but with error: " + strMsg;
		if (objErr) {
			objErr.firstChild.nodeValue = strMsg;
			objErr.style.display = "block";
		}
	}
	
	function setProcessError(strMsg, strID) {
		var objErr = document.getElementById(strID + '_err_msg');
		self.status = "Done but with error: " + strMsg;
		if (objErr) {
			objErr.firstChild.nodeValue = strMsg;
			objErr.style.display = "block";
		}
	}
	
	function resetError(strMsg) {
		var objErr = document.getElementById('process_err_msg');
		self.status = "Done";
		if (objErr) {
			objErr.firstChild.nodeValue = strMsg;
			objErr.style.display = "none";
		}
	}
	
	function resetProcessError(strMsg, strID) {
		var objErr = document.getElementById(strID + '_err_msg');
		self.status = "Done";
		if (objErr) {
			objErr.firstChild.nodeValue = strMsg;
			objErr.style.display = "none";
		}
	}
	
	function setProcessMsg(strMsg) {
		var objInfo = document.getElementById('process_info_msg');
		if (objInfo) {
			objInfo.firstChild.nodeValue = strMsg;
			objInfo.style.display = "block";
		}
	}
	
	function setSubProcessMsg(strMsg, strID) {
		var objInfo = document.getElementById(strID + "_info_msg");
		if (objInfo) {
			objInfo.firstChild.nodeValue = strMsg;
			objInfo.style.display = "block";
		}
	}
	
	function resetProcessMsg(strMsg) {
		var objInfo = document.getElementById('process_info_msg');
		if (objInfo) {
			objInfo.firstChild.nodeValue = strMsg;
			objInfo.style.display = "none";
		}
	}
	
	function resetSubProcessMsg(strMsg, strID) {
		var objInfo = document.getElementById(strID + "_info_msg");
		if (objInfo) {
			objInfo.firstChild.nodeValue = strMsg;
			objInfo.style.display = "none";
		}
	}
	
	function resetAll() {
		resetError("&nbsp;");
		resetProcessMsg("&nbsp;");
		enableSubmit();
	}
	
	/*
	// It'd be better to rewrite this disable/enableSubmit functions 
	// to take one parameter = submit button ID
	*/
	function disableSubmit() {
		var cmdSubmit = document.getElementById('btnSubmit');
		if (cmdSubmit) {
			cmdSubmit.disabled = true;
		}
	}
	
	function enableSubmit() {
		var cmdSubmit = document.getElementById('btnSubmit');
		if (cmdSubmit) {
			cmdSubmit.disabled = false;
		}
	}
	
	/*
	// well, this is just a patch to deal with situations 
	// when there are more than one form/button for job submission in the same page
	*/
	function enableSubmitOne() {
		var cmdSubmit = document.getElementById('btnSubmit1');
		if (cmdSubmit) {
			cmdSubmit.disabled = false;
		}
	}
	
	function disableSubmitOne() {
		var cmdSubmit = document.getElementById('btnSubmit1');
		if (cmdSubmit) {
			cmdSubmit.disabled = true;
		}
	}
	
	
/************************** END of FILE *************************************************/