//---------------------------------------------------------------------------------------------------------------
var mobjWindow;
var mobjDivMessage = "";
//--------------------------------------------------------------------------------------------
function DisplayMessage(astrMessage, aintMessageId){

    var lobjDivMessage = getElementById(mobjDivMessage);
    
    if (lobjDivMessage) {
          
        if (trim(astrMessage) == ""){
        
            lobjDivMessage.className = "";
            
            lobjDivMessage.innerHtml = "";
            
            lobjDivMessage.style.display = "none";    
        
        }
        
        else {
        
            switch (aintMessageId) {
                
                case "1" : lobjDivMessage.className = "clsSuccess"; break;
                
                case "2" : lobjDivMessage.className = "clsFailure"; break;
                
                case "3" : lobjDivMessage.className = "clsCaution"; break;

            }
            
            lobjDivMessage.innerHTML = astrMessage;
            
            lobjDivMessage.style.display = "block";    
        
        }
        
    }

}
//------------------------------------------------------------------------------------
function ShowValidDate(adteValue, blnNoDefault)
{
    if (adteValue != null && adteValue != "")
    {
        var dteCheck0 = replace(USDate(getElementById("minDate").value), "0", "").split(" ")[0];
        var dteCheck1 = replace(USDate(getElementById("maxDate").value), "0", "").split(" ")[0];
        var dteCheck2 = replace(USDate(adteValue), "0", "").split(" ")[0];
        
        var dteCheck  = (dteCheck2 == dteCheck0 || dteCheck2 == dteCheck1 || dteCheck2 == "1/1/19");
        
        return ((dteCheck || dteCheck2 == null) ? "" : USDate(adteValue));
    }
    return ((blnNoDefault) ? "" : USDate(Today()));
}
//------------------------------------------------------------------------------------
function isNull(Expression, DefaultValue)
{
    return ((Expression == null)? DefaultValue : Expression);
}
//------------------------------------------------------------------------------------
function isNumeric(str)
{
    // check we only have digits and minus characters
    for (var i = 0; i < str.length; i++) {
        var c = str.substring(i, i+1)
        if ((c<"0" || c>"9") && c!="-") 
        {
            return false;
        }
    }

    if (str.length==0) return false;

    return true;
}
// calculate the modified Julian day number from Gregorian date
//------------------------------------------------------------------------------------
function julianDay(year, month, day)
{
    year = Number(year);
    month = Number(month);
    day = Number(day);

    var extra = 100.0 * year + month - 190002.5;
    var julian = 367.0 * year;
    
    julian -= Math.floor(7.0*(year+Math.floor((month+9.0)/12.0))/4.0);
    julian += Math.floor(275.0*month/9.0);
    julian += day;
    julian -= 678985.5;
    julian -= 0.5*extra/Math.abs(extra);
    
    return julian;
}
// convert the modified Julian day number to Gregorian date
//------------------------------------------------------------------------------------
function calanderDay(julian)
{
    julian = Number(julian);

    var jd0 = julian+2400000.5;
    var z = Math.floor(jd0);
    var f = jd0-z;
    var a = 0.0;
    var alp = 0.0;
    if (z<2299161) {
            a = z;
    } else {
            alp = Math.floor((z-1867216.25)/36524.25);
            a = z+1.0+alp-Math.floor(alp/4.0);
    }

    var b = a+1524;
    var c = Math.floor((b-122.1)/365.25);
    var d = Math.floor(365.25*c);
    var e = Math.floor((b-d)/30.6001);

    var day = Math.floor(b-d-Math.floor(30.6001*e)+f);

    var month = 0;
    if (e<13.5) {month = e-1;} else {month = e-13;}

    var year = 0;
    if (month>2.5) {year = c-4716;} else {year = c-4715;}

    temp = new Array(3);
    temp[0] = FormatDateTime_Helper(day);
    temp[1] = FormatDateTime_Helper(month);
    temp[2] = FormatDateTime_Helper(year);

    return temp;
}
//------------------------------------------------------------------------------------
function dateAdd(Interval, NumToAdd, DateString, isUKdate)
{
    var str = new String();
    var arr = new Array();
    
    str = DateString; if (!isDate(str, isUKdate)) return;

    arr = str.split("/");
    var sy = Number(arr[2]);
    var sm = Number((isUKdate ? arr[1] : arr[0]));
    var sd = Number((isUKdate ? arr[0] : arr[1]));

    var ey = sy;
    var em = sm;
    var ed = sd;

    // need to check years,months,weeks and days are numbers
    var ad = new Number(0);
    var aw = new Number(0);
    var am = new Number(0); 
    var ay = new Number(0);
    
    NumToAdd = parseInt(Number(NumToAdd));
    
    switch (Interval)
    {   
        case "d" : case "1" : ad = NumToAdd; break;
        case "w" : case "2" : aw = NumToAdd; break; 
        case "M" : case "3" : am = NumToAdd; break; 
        case "y" : case "4" : ay = NumToAdd; break; 
    }    
    
    ey += ay;
        
   // add the months
    if (am > 12) {
        em += am % 12;
        ey += Math.floor(am/12);
    } 
    else {
        em += am;
    }
    if (em>12) {
        ey++; em -= 12;
    }

    // use julian day numbers to add weeks and days
    ej = julianDay(ey, em, ed);
    ej += (aw * 7) + ad;

    end = calanderDay(ej);
    
    returnDte = isUKdate ? end[0]+"/"+end[1]+"/"+end[2] : end[1]+"/"+end[0]+"/"+end[2];
    
    //bug fix:
    if (Interval == "y" || Interval == "4" || Interval == "M" || Interval == "3"){
        returnDte = dateAdd("d", -1, returnDte, isUKdate);
    }

    return (returnDte);
}
//----------------------------------------------------------------------------------------
function dateDiff(Interval, FromDate, ToDate, isUKdate)
{   
    var str = new String();
    var arr = new Array();
    
    str = FromDate; if (!isDate(str, isUKdate)) return;
    
    arr = str.split("/");
    var sy = Number(arr[2]);
    var sm = Number((isUKdate ? arr[1] : arr[0]));
    var sd = Number((isUKdate ? arr[0] : arr[1]));

    str = ToDate; if (!isDate(str, isUKdate)) return;
    //bug fix:
    if (Interval == "y" || Interval == "4" || Interval == "M" || Interval == "3"){
        str = dateAdd("d", 1, str, isUKdate);
    }

    arr = str.split("/");
    var ey = Number(arr[2]);
    var em = Number((isUKdate ? arr[1] : arr[0]));
    var ed = Number((isUKdate ? arr[0] : arr[1]));

    var sj = julianDay(sy, sm, sd);
    var ej = julianDay(ey, em, ed);

    if (ej < sj) {
        alert("End date must be later than start date");
        return;
    }
    
    var lstrResult = new String();
    
    switch (String(Interval)){
        
        case "d" : case "1" : 
        
            lstrResult = (ej-sj);
            break;
            
        case "w" : case "2" : 
        
            lstrResult = (Math.floor((ej-sj)/7));
            break;
            
        case "M" : case "3" : 
        
            md = ((ey*12)+em)-((sy*12)+sm);
            ed < sd ? md-- : md;
            lstrResult = md;
            //lstrResult = (ed < sd ? md-- : md);
            break;
            
        case "y" : case "4" : 
        
            yd = ey-sy;
            (em<sm) || ((em<sm) && (ed<sd)) ? yd-- : yd;
            lstrResult = yd;
            //lstrResult = ((em<sm) || ((em<sm) && (ed<sd)) ? yd-- : yd);
            break;
    
    }
    
    return lstrResult
        
}
//------------------------------------------------------------------------------------
function USDate(Expression){
    return FormatDateTime(Expression, "MM/dd/yyyy", false);
}
//------------------------------------------------------------------------------------
function Today(){
    var today = new Date();
    var offsetYear = 0; //1900
    return today.getMonth()+1+"/"+today.getDate()+"/"+(today.getYear() + offsetYear);
}
//------------------------------------------------------------------------------------
function FormatDateTime(Expression, vFormat, vAlert)
{       
    var vDate = (typeof(Expression) == "string") ? Expression : new Date(Expression);
    //e.g. FORMAT = dd/MM/yy hh:mm:ss
    
    var vDateString = new String();

    try {
    
        var vSecond     = FormatDateTime_Helper(vDate.getSeconds()); //ss = seconds
        var vMinute     = FormatDateTime_Helper(vDate.getMinutes()); //mm = minutes
        var vHour       = FormatDateTime_Helper(vDate.getHours()); //hh = hours
        var vDay        = FormatDateTime_Helper(vDate.getDate()); // dd = Date of the month
        var vMonth      = FormatDateTime_Helper(vDate.getMonth()+1); //MM = month
        var vYearLong   = FormatDateTime_Helper(vDate.getFullYear()); //yy = Year (Note: yyyy = 4 digit year)
        var vYearShort  = FormatDateTime_Helper(vDate.getFullYear().toString().substring(3,4)); 
        var vYear       = (vFormat.indexOf("yyyy") > -1 ? vYearLong : vYearShort);
        
        vDateString     = vFormat.replace(/dd/g, vDay).replace(/MM/g, vMonth).replace(/y{1,4}/g, vYear);
        vDateString     = vDateString.replace(/hh/g, vHour).replace(/mm/g, vMinute).replace(/ss/g, vSecond);
    
    }
    
    catch(e){
        
        if (vAlert) alert("Date cannot be formatted due to an error: Date = " + Expression + "\nError Message: " + e.message);
        vDateString = Expression;
    
    }
    
    return vDateString;
} 
//------------------------------------------------------------------------------------
function FormatDateTime_Helper(vNumber){ 
    return ((vNumber < 10) ? "0" : "") + vNumber;
} 
//------------------------------------------------------------------------------------
function jsApp_OpenHelpWindow(astrUrl){

	//set help window parameters
	var wx  = (screen.availWidth/4)
	var wy  = (screen.availHeight)		

	//open help window and move it to new location	
	var lstrWinNme = "helpWindow";	
	var lstrWinPrm = "top=" + wy + ",left=" + wx + ",scrollbars=yes,status=no," + 
						"toolbar=no,location=no,menubar=no,copyhistory=no,resizable=yes";
					
	mobjWindow = window.open(astrUrl, lstrWinNme, lstrWinPrm, true);	
	mobjWindow.resizeTo(wx,wy);	
	mobjWindow.moveTo((wx*3),0);
	
	if (window.focus){
	
		mobjWindow.focus();
		
	}	
	
	return false;
}
//------------------------------------------------------------------------------------
function jsForceNumeric(aobjElement){

    var lstrValue = trim(aobjElement.value);
    
    if (lstrValue != "" && isNaN(lstrValue)){
            
       aobjElement.value = lstrValue.substring(0, lstrValue.length-1);
    
    }

}
//---------------------------------------------------------------------------------------------------------------
function jsGetPosition(aobjElement){

    var curleft = curtop = 0;
    
    if(aobjElement.offsetParent) {
    
        while(1) {
        
          curleft += aobjElement.offsetLeft;
          curtop += aobjElement.offsetTop;
          
          if(!aobjElement.offsetParent) break;
          
          aobjElement = aobjElement.offsetParent;
          
        }
        
    }  
    else {

        if(aobjElement.x) curleft += aobjElement.x;
        if(aobjElement.y) curtop += aobjElement.y;
    }   
     
    return [curleft,curtop];
    
}

//---------------------------------------------------------------------------------------------------------------
function createCookie(name,value,days) {
  if (days) {
    var date = new Date();
    date.setTime(date.getTime()+(days*24*60*60*1000));
    var expires = "; expires="+date.toGMTString();
  }
  else expires = "";
  document.cookie = name+"="+value+expires+"; path=/";
}

//---------------------------------------------------------------------------------------------------------------
function readCookie(name) {
  var nameEQ = name + "=";
  var ca = document.cookie.split(';');
  for(var i=0;i < ca.length;i++) {
    var c = ca[i];
    while (c.charAt(0)==' ') c = c.substring(1,c.length);
    if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
  }
  return null;
}
//---------------------------------------------------------------------------------------------------------------
function jsIsPassword(astrValue){
    astrValue = jsTrim(astrValue).toLowerCase();
    
    if (astrValue.length < 6 || astrValue.length > 50) return false;

    for (i = 0; i < astrValue.length; i++){
        if (astrValue.substr(i, 1) < "a" || astrValue.substr(i, 1) > "z"){
            switch (astrValue.substr(i, 1)){
                case "0": case "1": case "2": case "3": case "4": case "5":
                case "6": case "7": case "8": case "9":
                    //Continue checking:
                    break;
                default:
                    return false;
            }
        }
    }
    return true;
}
//---------------------------------------------------------------------------------------------------------------
function jsIsAlphaNumeric(astrValue){
    astrValue = jsTrim(astrValue).toLowerCase();
    
    for (i = 0; i < astrValue.length; i++){
        if (astrValue.substr(i, 1) < "a" || astrValue.substr(i, 1) > "z"){
            switch (astrValue.substr(i, 1)){
                case "0": case "1": case "2": case "3": case "4": case "5":
                case "6": case "7": case "8": case "9":
                    //Continue checking:
                    break;
                default:
                    return false;                     
            }
        }        
    }
    return true;
}
//---------------------------------------------------------------------------------------------------------------
function jsRequestValue(astrElementName){
	var lstrValue = new String()
	var lobjForm = document.forms[0]
	var lobjElement = lobjForm.elements[astrElementName]
	var lblnIsMultiple = false;
	
	if (lobjElement){
		var lobjElementType = lobjElement.type;		
		
		if (typeof(lobjElementType) == 'undefined'){		    
		
		    lobjElementType = lobjElement[0].type; 
		
		    lblnIsMultiple = true
		
		}	
		
		try{
		
		    switch (lobjElementType.toLowerCase()){
    		
			    case 'select-one':
    			
				    lstrValue = (lobjElement.options.length > 0) ? 
				        lobjElement.options[lobjElement.options.selectedIndex].value : "";
    				
				    break;
    		
			    case 'select-multiple':
    			
				    lstrValue = jsGetFormMultiValue(lobjElement, lblnIsMultiple);
    				
				    break;
    			
			    case 'radio' :
    			
				    lstrValue = jsGetFormMultiValue(lobjElement, lblnIsMultiple);
    				
				    break;	
    				
			    case 'checkbox' :
    			
				    lstrValue = jsGetFormMultiValue(lobjElement, lblnIsMultiple);
    				
				    break;
    				
			    default : 
    			
				    lstrValue = lobjElement.value; 
    				
				    break;	
    					
		    }
		    
		}
		catch(e){
		
		    //alert("An error occured: " + e.message + " (" + astrElementName + ")");
		    lstrValue = "";
		
		}
	}
	
	return trim(lstrValue);
	
}
//---------------------------------------------------------------------------------------------------------------
function jsClearValue(astrElementName){

	var lobjForm = document.forms[0]
	var lobjElement = lobjForm.elements[astrElementName]
	var lblnIsMultiple = false;
	
	if (lobjElement){
		var lobjElementType = lobjElement.type;		
		
		if (typeof(lobjElementType) == 'undefined'){		    
		
		    lobjElementType = lobjElement[0].type; 
		
		    lblnIsMultiple = true
		
		}	
		
		switch (lobjElementType.toLowerCase()){
		
			case 'select-one':
			
			    SetSelectedIndex(astrElementName, "");
				
				break;
		
			case 'select-multiple':
			
				SetSelectedIndex(astrElementName, "", true);;
				
				break;
			
			case 'radio' :
			
				jsClearFormMultiValue(lobjElement, lblnIsMultiple);
				
				break;	
				
			case 'checkbox' :
			
				jsClearFormMultiValue(lobjElement, lblnIsMultiple);
				
				break;
				
			default : 
			
				lobjElement.value = ""; 
				
				break;	
					
		}
	}
	
	return;
	
}
//---------------------------------------------------------------------------------------------------------------
function jsGetFormMultiValue(aobjElement, ablnIsMultiple){	

    var lstrValue = new String();
    var lstrComma = new String();    

    if (aobjElement.type == "select-multiple" || aobjElement.type == "select-one"){
			
	    for (var i = 0; i < aobjElement.options.length; i++){
		
		    if (aobjElement.options[i].selected){
			
		        var strValue = lstrComma + aobjElement.options[i].value;
			
			    lstrValue = lstrValue.concat(strValue);	
    				
				lstrComma = ',';
				
		    }	
	    }
	    
    }

	else { 
	    if (ablnIsMultiple){
			
		    for (var i = 0; i < aobjElement.length; i++){
    		
			    if (aobjElement[i].checked){
    			
			        var strValue = lstrComma + aobjElement[i].value;	
    			
				    lstrValue = lstrValue.concat(strValue);	
    				
				    lstrComma = ',';
    				
			    }	
		    }
    		
	    }
    	
	    else if(aobjElement.checked){
    	
		    lstrValue = aobjElement.value;
    		
	    }
	}
	
	return lstrValue;
	
}
//---------------------------------------------------------------------------------------------------------------
function jsClearFormMultiValue(aobjElement, ablnIsMultiple){	

    var lstrValue = new String();
    var lstrComma = new String();    

    if (aobjElement.type == "select-multiple"){
			
	    for (var i = 0; i < aobjElement.options.length; i++){
		
		    aobjElement.options[i].selected = false;
	    }
	    
    }

	else { 
	    if (ablnIsMultiple){
			
		    for (var i = 0; i < aobjElement.length; i++){
    		
    		    aobjElement[i].checked =  false;
		    }
    		
	    }
    	
	    else {
    	
		    aobjElement.checked = false;
    		
	    }
	    
	}
	
}
//---------------------------------------------------------------------------------------------------------------
function getSelectedValue(astrElementName, lblnReturnText)
{    
    var lobjElement = document.forms[0].elements[astrElementName];
    if (lblnReturnText){
        return lobjElement.options[lobjElement.selectedIndex].text;
    }
    else {
        return lobjElement.options[lobjElement.selectedIndex].value;
    }
}
//---------------------------------------------------------------------------------------------------------------
function setSelectedValue(astrElementName, astrElementValue, byId)
{    
    var lobjForm = document.forms[0]
    var lobjElement = (byId ? getElementById(astrElementName) : lobjForm.elements[astrElementName]);
    
    if (lobjElement) {
    
        lobjElement.selectedIndex = 0;
        astrElementValue = trim(String(astrElementValue).toLowerCase());
        
        for (var i = 0; i < lobjElement.options.length; i++){
        
            var strValue = trim(lobjElement.options[i].value.toLowerCase());
            var strText = trim(lobjElement.options[i].text.toLowerCase());
            
            if (strValue == astrElementValue || strText == astrElementValue){
                 lobjElement.selectedIndex = i; break;
            }

        }
    }   
}
//---------------------------------------------------------------------------------------------------------------
function SetSelectedIndex(astrElementName, astrElementValue, lblnIsMultiple)
{
    var lobjForm = document.forms[0]
    var lobjElement = lobjForm.elements[astrElementName];
    
    if (lobjElement) {
    
        if (!lblnIsMultiple) {
        
            lobjElement.selectedIndex = ((lblnIsMultiple == null) ? 0 : -1);

            for (var i = 0; i < lobjElement.options.length; i++){

                var strValue = trim(lobjElement.options[i].value);

                if (strValue.toLowerCase() == trim(astrElementValue.toLowerCase())){

                    //lobjElement.selectedIndex = i;
                    lobjElement.options[i].selected = true;
                    
                    break;

                }

            }
        }
        
        else{
        
            for (var i = 0; i < lobjElement.options.length; i++){

                var strValue = "," + trim(lobjElement.options[i].value.toLowerCase()) + ",";
                
                astrElementValue = "," + astrElementValue.toLowerCase() + ",";
                
                lobjElement.options[i].selected = astrElementValue.indexOf(strValue) > -1 ? true : false;

            }        
        
        }
        
    }

}
//---------------------------------------------------------------------------------------------------------------
function rand(n) {
	var now = new Date();
	var seed = now.getTime() % 0xffffffff;
		seed = (0x015a4e35 * seed) % 0x7fffffff;
	return (seed >> 16 ) % n;
} 
//---------------------------------------------------------------------------------------------------------------
function postform(formAction, formValidate, formMethod, formTarget){
	var form = document.forms[0]
	//submit the form but check validation	
	if (eval(formValidate)){
		if (formAction == null){
			form.action = location.href
		}
		else if (formAction.indexOf(',') > -1){
			var astr = formAction.split(',')
			form.FRMACT.value = astr[0]
			form.action		  = astr[1]
		}
		else {
			form.FRMACT.value = formAction //set the form action
		}
		if ((typeof(formMethod)!='undefined')&&(formMethod != '')){
			form.method = formMethod} //set the form method
			
		if ((formTarget != null)&&(formTarget != '')){
			form.action = form.action + '#' + formTarget
		}	
		form.submit()
	} 
}
//---------------------------------------------------------------------------------------------------------------
function getElementById(aobjElementId, ablnReturnValue){return document.getElementById(aobjElementId);}
//---------------------------------------------------------------------------------------------------------------
function jsFindSelectOne(astrElementName, ablnReturnValue){
    return jsFindFormElement(astrElementName, 'select-one', ablnReturnValue);}
//---------------------------------------------------------------------------------------------------------------
function jsFindSelectMultiple(astrElementName, ablnReturnValue){
    return jsFindFormElement(astrElementName, 'select-multiple', ablnReturnValue);}
//---------------------------------------------------------------------------------------------------------------
function jsFindTextBox(astrElementName, ablnReturnValue){
    return jsFindFormElement(astrElementName, 'text', ablnReturnValue);}
//---------------------------------------------------------------------------------------------------------------
function jsFindTextArea(astrElementName, ablnReturnValue){
    return jsFindFormElement(astrElementName, 'textarea', ablnReturnValue);}
//---------------------------------------------------------------------------------------------------------------
function jsFindCheckBox(astrElementName, ablnReturnValue){
    return jsFindFormElement(astrElementName, 'checkbox', ablnReturnValue);}
//---------------------------------------------------------------------------------------------------------------
function jsFindHidden(astrElementName, ablnReturnValue){
    return jsFindFormElement(astrElementName, 'hidden', ablnReturnValue);}
//---------------------------------------------------------------------------------------------------------------
function jsFindFile(astrElementName, ablnReturnValue){
    return jsFindFormElement(astrElementName, 'file', ablnReturnValue);}
//---------------------------------------------------------------------------------------------------------------
function jsFindFormElement(astrElementName, astrElementType, ablnReturnValue){

    var lobjForm = document.forms[0];
    var lobjElementName = "";
    
    for (var i = 0; i < lobjForm.elements.length; i++){
    
        var lobjElement = lobjForm.elements[i];
        
        if (lobjElement.type == astrElementType){
        
            var objElementName = lobjElement.name;
            var intEndPosition = objElementName.length;
            var intStartPosition = intEndPosition - astrElementName.length;
            
            if (objElementName.substring(intStartPosition, intEndPosition) == astrElementName) {
            
                lobjElementName = objElementName;
                
                break;
                
            }
        
        }
    
    }
    
    //return element value
    if (typeof(ablnReturnValue) != "undefined" && lobjElementName != "")
    {
        if (ablnReturnValue == null)
        {
            return lobjForm.elements[lobjElementName];
        }
        else
        {
            if (ablnReturnValue) 
            {
                return jsRequestValue(lobjElementName)
            }
            
            else
            {
                return jsClearValue(lobjElementName)
            }
        }
    }
    
    //return element name
    return lobjElementName;
    
}
//---------------------------------------------------------------------------------------------------------------
function jsFindTagById(astrTagName, astrTagId, ablnReturnValue){

	var lobjElement = "";	
	var lstrTagId = jsFindTag(astrTagName, "id", astrTagId, ablnReturnValue)

    if (lstrTagId != "") {
    
    	lobjElement = getElementById(lstrTagId);
    	
    	if (ablnReturnValue){
    		
	    	return lobjElement.innerHTML;
	    		
		}
    	
		else if (ablnReturnValue == null) {
		
	    	lobjElement.innerHTML = "";
	    	
    	}
    
    }

	return lobjElement;    

}
//---------------------------------------------------------------------------------------------------------------
function jsFindTagByName(astrTagName, astrAttribute, astrAttributeValue){

}
//---------------------------------------------------------------------------------------------------------------
function jsFindTag(astrTagName, astrAttribute, astrAttributeValue, ablnReturnValue){

    var lobjTags = "";
    var lobjTagAttributeValue = "";
    var lobjElement = "";
    
    astrTagName = astrTagName.toLowerCase(); 
    astrAttribute = astrAttribute.toLowerCase(); 
    
	if (document.all){ 
		lobjTags = document.all.tags(astrTagName);
	}
	else if (document.getElementsByTagName){ 
		lobjTags = document.getElementsByTagName(astrTagName);
	}
	else if (document.layers){ 
		lobjTags = document.layers[astrTagName];
	}
	else{ 
		return null;
	}
    
    for (var i = 0; i < lobjTags.length; i++){   
    
        var strActualAttributeValue = lobjTags.item(i).getAttribute(astrAttribute);
         
        var intEndPosition = strActualAttributeValue.length;
        var intStartPosition = intEndPosition - astrAttributeValue.length;
        var strAttributeValue = strActualAttributeValue.substring(intStartPosition, intEndPosition);
        
        if (strAttributeValue == astrAttributeValue) {
        
            lobjTagAttributeValue = strActualAttributeValue;
            
            break;
            
        }
        
    }
    
    return lobjTagAttributeValue;
    
}
//---------------------------------------------------------------------------------------------------------------
var subWindow;
function handleFocus(){
	if (subWindow){	
		if (!subWindow.closed){
			subWindow.focus();	
		} 
		else {
			if (window.onfocus == handleFocus){
				window.onfocus = "";
			}
		}
	}
}
//---------------------------------------------------------------------------------------------------------------
function OpenWindow(Location, Name, Width, Height, Params, NoModal){
	var lblnMozilla = (window.navigator.appName.toLowerCase().indexOf("microsoft") == -1?true:false); 

	//window dimensions
	if (Width  == ''){Width  = '350'}
	if (Height == ''){Height = '350'}
	
	//window parameters
	if (Params == ''){Params = 'menubar=no,status=no,toolbar=no,location=no,' +
								'scrollbars=no,copyhistory=no,resizable=no'}							
	//set the window features
	if ((Params.toLowerCase().indexOf('top') > -1)||(Params.toLowerCase().indexOf('left') > -1)){
		Params = Params + ',width='+Width+',height='+Height
	}
	else{
		//window positions
		Left = axis('x',Width)
		Top  = axis('y',Height)	
		Params = Params + ',width='+Width+',height='+Height+',top='+Top+',left='+Left
	}

	//If the browser is mozilla based, then we have to simulate a modal window, if its IE, then we use
	//the built in modal window:
	if ((NoModal)||(lblnMozilla)){
		if (window.onfocus){
			var funWindowFocus = window.onfocus; 
			window.onfocus = new Function("funWindowFocus(); handleFocus();"); 
		}
		else {
		    //open window
			window.onfocus = handleFocus; 
	        subWindow = window.open(Location, Name, Params, true)
            subWindow.focus();
		}		
	}
	else {
		//Its IE show we are going to use the showModalDialog method	
		var strValue = window.showModalDialog(Location, 'Name', 'dialogHeight: '+Height+'px; dialogWidth: '+Width+'px'); 
	}	
}
//---------------------------------------------------------------------------------------------------------------
function axis(n,d){
//Define the x and y coordinates for the window: 
//var x = (window.parent.document.body.offsetWidth / 2) - (500 / 2) + window.parent.document.body.scrollLeft; 
//var	y = (window.parent.document.body.clientHeight / 2) - (500 / 2) + window.parent.document.body.scrollTop; 
	if (lcase(n) == 'x'){
		var axis_x = window.screen.availWidth
		return ((axis_x/2)-(d/2))
	}	
	else if (lcase(n) == 'y'){
		var axis_y = window.screen.availHeight	
		return ((axis_y/2)-(d/2))
	}	
}
//---------------------------------------------------------------------------------------------------------------
function requestQS(param,opener){
	var result = new Array()
	var x = 0
	var loc = location.search.split('?')
	if (opener){
		loc = window.opener.location.search.split('?')
	}
	if (typeof(loc[1]) != 'undefined'){
		var str = loc[1].split('&')
		for (var i=0; i<str.length; i++){
			var val = str[i].split('=')
			var prm = trim(val[0])
			var val = trim(val[1])
			if (param == prm){
				result[x] = val; x = (x+1)
			}
	
		}
	}	
	return (result.join(','))
}
//---------------------------------------------------------------------------------------------------------------
function IsValidData(expression, datatype, optParam){
	var reg
	if (datatype == 2){//web address
	//	reg	= /(http|ftp|https):\/\/[\w]+(.[\w]+)([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/;
		reg = /((mailto\:|(news|(ht|f)tp(s?))\:\/\/){1}\S+)/;
		if (!reg.test(expression)){return false;}	
	}
	if (datatype == 4){//number
		if (isNaN(expression)){return false;}
	}
	if ((datatype == 5)||(datatype == 14)) {//date
		reg = /^\d{1,2}\/\d{1,2}\/\d{4}$/
		if (!reg.test(expression)){
			return false;}
		else if (expression.split('/')[2] < '1753'){
			return false;}
		else {return isValidDate(expression, optParam)}	
	}
	if (datatype == 6){//email
	//	reg = /^[\w-]+(?:[\.\'][\w-]+)*@(?:[\w-]+\.)+[a-zA-Z]{2,7}$/;
		reg = /^[\w\.-]+@[\w\.-]+\.[a-zA-Z]+$/;
		if (!reg.test(expression)){return false;}
	}

	if (datatype == 7){//currency
		//reg = /^(\$|\¥|\€|\£)?([0-9]{1,3},([0-9]{3},)*[0-9]{3}|[0-9]+)(.[0-9][0-9])?$/	
		reg = /^([0-9]{1,3},([0-9]{3},)*[0-9]{3}|[0-9]+)(.[0-9][0-9])?$/
	 	if (!reg.test(expression)){return false;}
	 }
	/*
	if (datatype == 9){alert('password')//password
		reg = /^[a-zA-Z]\w{3,14}$/;
		if (!reg.test(expression)){return false;}
	}
	*/
	if (datatype == 10){//username
		reg = /^[\w\-]+$/
		if (!reg.test(expression)){return false;}
	}
	
	//if all is fine,
	return true;
}
//---------------------------------------------------------------------------------------------------------------
function isDate(expression, isUKdate){
    return IsValidData(expression, 5, isUKdate)
}
//---------------------------------------------------------------------------------------------------------------
function isNotValidDateRange(fromDate, toDate) {
	var dteval1 = Date.parse(fromDate)
	var dteval2 = Date.parse(toDate)
	return ((dteval1 - dteval2) > 0)
}
//---------------------------------------------------------------------------------------------------------------
function isValidDate(expression, isUKdate) {
	var myMonthArr = new Array('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec')
	var myMonthStr = myMonthArr[expression.split('/')[isUKdate ? 1 : 0]-1]
	var myDate     = new Date(expression);
	var myDate_string = myDate.toGMTString();
	var myDate_array = myDate_string.split( ' ' );
	//if (myDate_array[2]!=myMonthStr){return false}else{return true} 
	if (myMonthArr[myDate.getMonth()] != myMonthStr){return false}else{return true}
}
//------------------------------------------------------------------------------------
function checkDate(str)
{
    months = new Array(31,29,31,30,31,30,31,31,30,31,30,31);

    // check we only have digits and backslash characters
    for (var i=0;i<str.length;i++) {
            var c = str.substring(i, i+1)
            if ((c<"0" || c>"9") && c!="/") {
                    alert("Date "+str+" is invalid");
                    return false;
            }
    }

    // make sure we only have three components
    temp = str.split("/"); if (temp.length!=3) {return false;}

    var y = parseInt(temp[2]);
    var m = parseInt(temp[1]);
    var d = parseInt(temp[0]);

    // check the day and month values are valid
    if ((m<1) || (d<1) || (m>12) || (d>months[m-1])) {return false;}

    if ((y%4!=0) || ((y%100==0) && (y%400!=0))) {
        if ((m==2) && (d>28)) {return false;}
    }

    // check date is in range of modified Julian day number
    if ((y<1858) || (y>2132)) {return false;}

    if ((y==1858) && ((m<11) || ((m==11) && (d<16)))) {return false;}

    if ((y==2132) && ((m>8) || ((m==8) && (d>29)))) {return false;}

    return true;
}
//---------------------------------------------------------------------------------------------------------------
function replace(Expression, SearchFor, ReplaceWith) 
{
    if (Expression == null) return;
    return (String(Expression).split(SearchFor)).join(ReplaceWith);  
}
//---------------------------------------------------------------------------------------------------------------
function selectnone(astrElementName){select(astrElementName, false);}
//---------------------------------------------------------------------------------------------------------------
function selectall(astrElementName){select(astrElementName, true);}
//---------------------------------------------------------------------------------------------------------------
function select(astrElementName, ablnIsSelected){

    var lobjElement = jsFindSelectMultiple(astrElementName, null);        
    lobjElement = document.forms[0].elements[lobjElement];
    
    if (lobjElement){
    
         for (var i = 0; i < lobjElement.options.length; i++){
         
            lobjElement.options[i].selected = ablnIsSelected;

        }       
    
    }

}
//---------------------------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------------------------
function ltrim(str){return String(str).replace(/^[ ]+/,'');}
function rtrim(str){return String(str).replace(/[ ]+$/,'');}
function trim(str){return ltrim(rtrim(String(str)));}
function lcase(str){return (String(str).toLowerCase());}
function ucase(str){return (String(str).toUpperCase());}
function left(str,len){return (String(str).substr(0,len));}
function right(str,len){return (String(str).substr(String(str).length-len,len));}
function bool(str,cpr){return (cpr==null?Boolean(lcase(str)):Boolean(lcase(str)==lcase(cpr)));}
//---------------------------------------------------------------------------------------------------------------
function removeHTMLTags(strText){
	var regEx = /<[^>]*>/g;
	return strText.replace(regEx, "")
}
//---------------------------------------------------------------------------------------------------------------
function replaceTag(strText, find, rplc){
	return strText.replace(eval('/'+find+'/g'), rplc)
}
//---------------------------------------------------------------------------------------------------------------
//function replace(strText, astrFind, astrReplaceWith){
//	return String(strText).replace(eval('/'+astrFind+'/g'), astrReplaceWith);
//}
//------------------------------------------------------------------------------------------------------
function FormatDuration(Expression)
{
    try
    {
        var min = parseInt(Expression/60);
        var sec = parseInt(Expression%60);
    }
    catch(e)
    {
        return Expression;
    }
    
    return min  + ":" + (String(sec).length == 1 ? "0" + sec : sec);
}
//------------------------------------------------------------------------------------------------------
function FormatPercent(Expression, NumDigits, blnLeadingZero, blnUseParens, blnGroupDigits)
{
    var tmpStr = new String(Expression*100)
	tmpStr = new String(FormatNumber(tmpStr, NumDigits, blnLeadingZero, blnUseParens, blnGroupDigits));

	if (tmpStr.indexOf(")") != -1) {
		// We know we have a negative number, so place '%' inside of ')'
		tmpStr = tmpStr.substring(0,tmpStr.length - 1) + "%)";
		return tmpStr;
	}
	else
		return tmpStr + "%";			// Return formatted string!
}

//------------------------------------------------------------------------------------------------------
function FormatCurrency(Expression, NumDigits, blnLeadingZero, blnUseParens, blnGroupDigits)
{
	var tmpStr = new String(FormatNumber(Expression, NumDigits, blnLeadingZero, blnUseParens, blnGroupDigits));

	if (tmpStr.indexOf("(") != -1 || tmpStr.indexOf("-") != -1) {
		// We know we have a negative number, so place '$' inside of '(' / after '-'
		if (tmpStr.charAt(0) == "(")
			tmpStr = "($"  + tmpStr.substring(1,tmpStr.length);
		else if (tmpStr.charAt(0) == "-")
			tmpStr = "-$" + tmpStr.substring(1,tmpStr.length);
			
		return tmpStr;
	}
	else
		return "$" + tmpStr;		// Return formatted string!
}
//------------------------------------------------------------------------------------------------------
function FormatNumber(Expression, NumDigits, blnLeadingZero, blnUseParens, blnGroupDigits)
{
    Expression = Number(String(Expression).split(",").join(""));
	var tmpNum = Expression;
	
    if (isNaN(tmpNum)) return tmpNum;
    if (isNaN(Number(NumDigits))) NumDigits = 10;
	
	var blnSkipRound = false;
	var tmpExpr = String(tmpNum).split(".");
	if (tmpExpr.length == 2) blnSkipRound = (tmpExpr[1].length <= NumDigits);
	
	if (!blnSkipRound) 
	{
	    // Adjust number so only the specified number of numbers after
	    // the decimal point are shown.
	    var iSign = tmpNum < 0 ? -1 : 1; // Get sign of number
    	tmpNum *= Math.pow(10,NumDigits);
    	tmpNum = Math.round(Math.abs(tmpNum));
    	tmpNum /= Math.pow(10,NumDigits);
	    tmpNum *= iSign;// Re-adjust for sign
	}
	
	// Create a string object to do our formatting on
	var tmpNumStr = new String(tmpNum);

	// See if we need to strip out the leading zero or not.
	if (!blnLeadingZero && Expression < 1 && Expression > -1 && Expression != 0)
		if (Expression > 0)
			tmpNumStr = tmpNumStr.substring(1,tmpNumStr.length);
		else
			tmpNumStr = "-" + tmpNumStr.substring(2,tmpNumStr.length);
		
	// See if we need to put in the commas
	if (blnGroupDigits && (Expression >= 1000 || Expression <= -1000)) {
		var iStart = tmpNumStr.indexOf(".");
		if (iStart < 0)
			iStart = tmpNumStr.length;

		iStart -= 3;
		while (iStart >= 1) {
			tmpNumStr = tmpNumStr.substring(0,iStart) + "," + tmpNumStr.substring(iStart,tmpNumStr.length)
			iStart -= 3;
		}		
	}

	// See if we need to use parenthesis
	if (blnUseParens && Expression < 0)
		tmpNumStr = "(" + tmpNumStr.substring(1,tmpNumStr.length) + ")";

    if (NumDigits > 0)
    {
        var chkDot = tmpNumStr.split(".");
        
        if (chkDot.length == 1) {
            tmpNumStr = tmpNumStr + "." + GetStr("0", NumDigits);
        }
        else if (chkDot.length == 2){
            tmpNumStr += GetStr("0", NumDigits - chkDot[1].length);
        }
    }
    
	return tmpNumStr;		// Return our formatted string!
}
//------------------------------------------------------------------------------------------------------
function GetStr(Expression, Count){
    
    var lstrResult = new String();
    for (var i = 0; i < Count; i++) lstrResult += Expression;
    
    return lstrResult;
}
//------------------------------------------------------------------------------------------------------
function formatDateTime(Expression, FormatType)
/*
	 FomatType takes the following values
		1 - General Date = Friday, October 30, 1998
		2 - Typical Date = 10/30/98
		3 - Standard Time = 6:31 PM
		4 - Military Time = 18:31
*/
{
	var strDate = new String(Expression);

	if (strDate.toUpperCase() == "NOW") {
		var myDate = new Date();
		strDate = String(myDate);
	} else {
		var myDate = new Date(Expression);
		strDate = String(myDate);
	}


	// Get the date variable parts
	var Day = new String(strDate.substring(0,3));
	if (Day == "Sun") Day = "Sunday";
	if (Day == "Mon") Day = "Monday";
	if (Day == "Tue") Day = "Tuesday";
	if (Day == "Wed") Day = "Wednesday";
	if (Day == "Thu") Day = "Thursday";
	if (Day == "Fri") Day = "Friday";
	if (Day == "Sat") Day = "Saturday";	
	
	var Month = new String(strDate.substring(4,7)), MonthNumber = 0;
	if (Month == "Jan") { Month = "January"; MonthNumber = 1; }
	if (Month == "Feb") { Month = "February"; MonthNumber = 2; }
	if (Month == "Mar") { Month = "March"; MonthNumber = 3; }
	if (Month == "Apr") { Month = "April"; MonthNumber = 4; }
	if (Month == "May") { Month = "May"; MonthNumber = 5; }
	if (Month == "Jun") { Month = "June"; MonthNumber = 6; }
	if (Month == "Jul") { Month = "July"; MonthNumber = 7; }
	if (Month == "Aug") { Month = "August"; MonthNumber = 8; }
	if (Month == "Sep") { Month = "September"; MonthNumber = 9; }
	if (Month == "Oct") { Month = "October"; MonthNumber = 10; }
	if (Month == "Nov") { Month = "November"; MonthNumber = 11; }
	if (Month == "Dec") { Month = "December"; MonthNumber = 12; }
	
	var curPos = 11;
	var MonthDay = new String(strDate.substring(8,10));
	if (MonthDay.charAt(1) == " ") {
		MonthDay = "0" + MonthDay.charAt(0);
		curPos--;
	}	
	
	var MilitaryTime = new String(strDate.substring(curPos,curPos + 5));
	
	var Year = new String(strDate.substring(strDate.length - 4, strDate.length));	
	
	document.write(strDate + "");	

	// Format Type decision time!
	if (FormatType == 1)
		strDate = Day + ", " + Month + " " + MonthDay + ", " + Year;
	else if (FormatType == 2)
		strDate = MonthNumber + "/" + MonthDay + "/" + Year.substring(2,4);
	else if (FormatType == 3) {
		var AMPM = MilitaryTime.substring(0,2) >= 12 && MilitaryTime.substring(0,2) != "24" ? " PM" : " AM";
		if (MilitaryTime.substring(0,2) > 12)
			strDate = (MilitaryTime.substring(0,2) - 12) + ":" + MilitaryTime.substring(3,MilitaryTime.length) + AMPM;
		else {
			if (MilitaryTime.substring(0,2) < 10)
				strDate = MilitaryTime.substring(1,MilitaryTime.length) + AMPM;
			else
				strDate = MilitaryTime + AMPM;
		}
	}	
	else if (FormatType == 4)
		strDate = MilitaryTime;


	return strDate;
}
//------------------------------------------------------------------------------------------------------
function len(str){  return String(str).length;  }
//------------------------------------------------------------------------------------------------------
function mid(str, start, len)
{
	// Make sure start and len are within proper bounds
	if (start < 0 || len < 0) return "";

	var iEnd, iLen = String(str).length;
        if (start + len > iLen)
        	iEnd = iLen;
	else
        	iEnd = start + len;

	return String(str).substring(start,iEnd);
}
//------------------------------------------------------------------------------------------------------
function inStr(strSearch, charSearchFor)
{
	for (i=0; i < Len(strSearch); i++)
	{
	    if (charSearchFor == Mid(strSearch, i, 1))
	    {
			return i;
	    }
	}
	return -1;
}
//------------------------------------------------------------------------------------------------------
function trimlen(str, len, pre, suf)
{
    if (trim(str) == "") return "";
    
    var tmpStr = new String();
    
    if (str.length <= len) {
        tmpStr = str;
    }
    else {
        tmpStr = mid(str, 0, len-3) + "...";
    }
    
    tmpStr = (typeof(pre)!="undefined") ? pre + tmpStr : tmpStr;
    tmpStr = (typeof(suf)!="undefined") ? tmpStr + suf : tmpStr;
    
    return tmpStr;
}
//------------------------------------------------------------------------------------------------------