/////////////////////////////////////////////////////////////////
//
//  App_Scripts.UI.js JScript File
//  This file contains functions related to USER INTERFACE.
//
//---------------------------------------------------------------
//  (C) 2008 Copyright JVC Canada 
//---------------------------------------------------------------

// Auto-enable Flash in IE
objects = document.getElementsByTagName("object");
for (var i = 0; i < objects.length; i++)
{
objects[i].outerHTML = objects[i].outerHTML;
} 

function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}

function MM_preloadImages() { //v3.0
  var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
    var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
    if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
}

//this function finds an element that contains certain text in its id
//it's used to battle mangled id naming when using master pages
function findIdWithText (text,controlName) {

    var elems = window.document.body.getElementsByTagName(controlName);
    var elem = null;    
    
    for (var i=0; i<elems.length; i++) {
        
        if (elems[i].id.indexOf(text)>-1) {
            elem = elems[i];
            break;
        }
    }
    
    return elem;
}

function GetObjValue(objID)
{
    var ctl = MM_findObj(objID);
    if (ctl!=null)
        {
            if (ctl.value!=null) return ctl.value;
            if (ctl.innerHTML!=null) return ctl.innerHTML;
        }
    else
        return "";
}
function SetObjValue(objID, val)
{
    var ctl = MM_findObj(objID);
    if (ctl!=null)
        {   
            ctl.innerHTML=val; 
            ctl.value=val;
        }
}

function MM_findObj(n, d) { //v4.01
  var p,i,x;  
  if(!d) d=document; 
  
  if( (p=n.indexOf("?") ) > 0 && parent.frames.length) 
	{
		d = parent.frames[n.substring(p+1)].document; 
		n = n.substring(0,p);
	}
  
  if(!(x=d[n]) && d.all) x=d.all[n]; 
  
  for (i=0;!x&&i<d.forms.length;i++) 
	x=d.forms[i][n];
  for (i=0;!x&&d.layers&&i<d.layers.length;i++) 
	x=MM_findObj(n,d.layers[i].document);
	
  if(!x && d.getElementById) 
	x=d.getElementById(n); 
	
	return x;
}

// DropdownTextGet()
// Get text selected from a dropdown control
// Parameters: ctl_ID - control ID
function DropdownTextGet(ctl_ID)
{
    var ctl = MM_findObj(ctl_ID);
    var txt = "";
    
    if (ctl != null)
    {
        txt = ctl.options[ctl.selectedIndex].text;
    }
    return txt;
}

// DropdownTextGet()
// Get value selected from a dropdown control
// Parameters: ctl_ID - control ID
function DropdownValueGet(ctl_ID)
{
    var ctl = MM_findObj(ctl_ID);
    var txt = "";
    
    if (ctl != null)
    {
        txt = ctl.options[ctl.selectedIndex].value;
    }
    return txt;
}

// ToggleView() 
//   Show or Hide object. If a <IMAGE> tag is available with
//   the sufix "PlusPix", then automatically toggles between PLUS and MINUS pictures. 
//   IMPORTANT: "nodePlus.gif" and "nodeMinus.gif" must be in the directory "img/ico/".
//   Author: Richard Oliveira on 01/20/2003
function ToggleView(objID)
   {
         var obj = MM_findObj(objID);
		 var objPix = MM_findObj(objID + "Pix");
		 
		 if (obj.style.display == "none") {
		 	obj.style.display = ""; 
			} else {
			obj.style.display = "none";
			}
			
		 if (objPix != null) {
		 	if (obj.style.display == "none") {
				objPix.src = "../img/bul/nodePlus.gif";
				} else {
				objPix.src = "../img/bul/nodeMinus.gif";
				}
		 	}
	}

// ToggleViewPix() 
//   Show or Hide object and toggle picture. 
//   Parameters: 	objID		- ID of the object to be displayed
//					objIDPix	- ID of the object which picture will be toggled
//					PixShow		- URL of the picture used to display object
//					PixHide		- URL of the picture used to hide object
//   Author: Richard Oliveira on 01/20/2003
function ToggleViewPix(objID, objIDPix, PixShow, PixHide)
   {
         var obj = MM_findObj(objID);
		 var objPix = MM_findObj(objIDPix);
		 
		 if (obj.style.display == "none") {
		 	obj.style.display = ""; 
			} else {
			obj.style.display = "none";
			}
			
		 if (objPix != null) {
		 	if (obj.style.display == "none") {
				objPix.src = PixShow; 
				} else {
				objPix.src = PixHide;
				}
		 	}			
	}


function CheckAll(chkPrefix)
{

	var isCheck=null; 
	var obj = document.getElementsByTagName("FORM");
	obj = obj[0];
	try
	{
	for (var i=0;i<obj.elements.length;i++)
	{
		var e=obj.elements[i];
		if ((e.name.indexOf(chkPrefix)>0) && (e.type=='checkbox'))
		{
			if (isCheck==null) 
			{
				if (e.checked == true)
					isCheck = false; 
				else
					isCheck = true;
			}
			e.checked = isCheck;
		}
	   	
	}
	}
	catch(e){}
	return true;
}


////////////////////////////////////////////////////////////////////////////////////////////
///
//  --------------------------------------------------------------
//      V A L I D A T I O N
//  --------------------------------------------------------------
//  

//-------------------------------------------------------------------
// isNull(value)
//   Returns true if value is null
//-------------------------------------------------------------------
function isNull(val){return(val==null);}

//-------------------------------------------------------------------
// isBlank(value)
//   Returns true if value only contains spaces
//-------------------------------------------------------------------
function isBlank(val){
	if(val==null){return true;}
	for(var i=0;i<val.length;i++) {
		if ((val.charAt(i)!=' ')&&(val.charAt(i)!="\t")&&(val.charAt(i)!="\n")&&(val.charAt(i)!="\r")){return false;}
		}
	return true;
	}

//-------------------------------------------------------------------
// isInteger(value)
//   Returns true if value contains all digits
//-------------------------------------------------------------------
function isInteger(val){
	if (isBlank(val)){return false;}
	for(var i=0;i<val.length;i++){
		if(!isDigit(val.charAt(i))){return false;}
		}
	return true;
	}

//-------------------------------------------------------------------
// isNumeric(value)
//   Returns true if value contains a positive float value
//-------------------------------------------------------------------
function isNumeric(val){return(parseFloat(val,10)==(val*1));}

//-------------------------------------------------------------------
// isArray(obj)
// Returns true if the object is an array, else false
//-------------------------------------------------------------------
function isArray(obj){return(typeof(obj.length)=="undefined")?false:true;}

//-------------------------------------------------------------------
// isDigit(value)
//   Returns true if value is a 1-character digit
//-------------------------------------------------------------------
function isDigit(num) {
	if (num.length>1){return false;}
	var string="1234567890";
	if (string.indexOf(num)!=-1){return true;}
	return false;
	}

//-------------------------------------------------------------------
// setNullIfBlank(input_object)
//   Sets a form field to "" if it isBlank()
//-------------------------------------------------------------------
function setNullIfBlank(obj){if(isBlank(obj.value)){obj.value="";}}

//-------------------------------------------------------------------
// setFieldsToUpperCase(input_object)
//   Sets value of form field toUpperCase() for all fields passed
//-------------------------------------------------------------------
function setFieldsToUpperCase(){
	for(var i=0;i<arguments.length;i++) {
		arguments[i].value = arguments[i].value.toUpperCase();
		}
	}

//-------------------------------------------------------------------
// disallowBlank(input_object[,message[,true]])
//   Checks a form field for a blank value. Optionally alerts if 
//   blank and focuses
//-------------------------------------------------------------------
function disallowBlank(obj){
	var msg=(arguments.length>1)?arguments[1]:"";
	var dofocus=(arguments.length>2)?arguments[2]:false;
	if (isBlank(getInputValue(obj))){
		if(!isBlank(msg)){alert(msg);}
		if(dofocus){
			if (isArray(obj) && (typeof(obj.type)=="undefined")) {obj=obj[0];}
			if(obj.type=="text"||obj.type=="textarea"||obj.type=="password") { obj.select(); }
			obj.focus();
		}
		return true;
		}
	return false;
	}

//-------------------------------------------------------------------
// disallowModify(input_object[,message[,true]])
//   Checks a form field for a value different than defaultValue. 
//   Optionally alerts and focuses
//-------------------------------------------------------------------
function disallowModify(obj){
	var msg=(arguments.length>1)?arguments[1]:"";
	var dofocus=(arguments.length>2)?arguments[2]:false;
	if (getInputValue(obj)!=getInputDefaultValue(obj)){
		if(!isBlank(msg)){alert(msg);}
		if(dofocus){
			if (isArray(obj) && (typeof(obj.type)=="undefined")) {obj=obj[0];}
			if(obj.type=="text"||obj.type=="textarea"||obj.type=="password") { obj.select(); }
			obj.focus();
			}
		setInputValue(obj,getInputDefaultValue(obj));
		return true;
		}
	return false;
	}

//-------------------------------------------------------------------
// commifyArray(array[,delimiter])
//   Take an array of values and turn it into a comma-separated string
//   Pass an optional second argument to specify a delimiter other than
//   comma.
//-------------------------------------------------------------------
function commifyArray(obj,delimiter){
	if (typeof(delimiter)=="undefined" || delimiter==null) {
		delimiter = ",";
		}
	var s="";
	if(obj==null||obj.length<=0){return s;}
	for(var i=0;i<obj.length;i++){
		s=s+((s=="")?"":delimiter)+obj[i].toString();
		}
	return s;
	}

//-------------------------------------------------------------------
// getSingleInputValue(input_object,use_default,delimiter)
//   Utility function used by others
//-------------------------------------------------------------------
function getSingleInputValue(obj,use_default,delimiter) {
	switch(obj.type){
		case 'radio': case 'checkbox': return(((use_default)?obj.defaultChecked:obj.checked)?obj.value:null);
		case 'text': case 'hidden': case 'textarea': return(use_default)?obj.defaultValue:obj.value;
		case 'password': return((use_default)?null:obj.value);
		case 'select-one':
			if (obj.options==null) { return null; }
			if(use_default){
				var o=obj.options;
				for(var i=0;i<o.length;i++){if(o[i].defaultSelected){return o[i].value;}}
				return o[0].value;
				}
			if (obj.selectedIndex<0){return null;}
			return(obj.options.length>0)?obj.options[obj.selectedIndex].value:null;
		case 'select-multiple': 
			if (obj.options==null) { return null; }
			var values=new Array();
			for(var i=0;i<obj.options.length;i++) {
				if((use_default&&obj.options[i].defaultSelected)||(!use_default&&obj.options[i].selected)) {
					values[values.length]=obj.options[i].value;
					}
				}
			return (values.length==0)?null:commifyArray(values,delimiter);
		}
	alert("FATAL ERROR: Field type "+obj.type+" is not supported for this function");
	return null;
	}

//-------------------------------------------------------------------
// getSingleInputText(input_object,use_default,delimiter)
//   Utility function used by others
//-------------------------------------------------------------------
function getSingleInputText(obj,use_default,delimiter) {
	switch(obj.type){
		case 'radio': case 'checkbox': 	return "";
		case 'text': case 'hidden': case 'textarea': return(use_default)?obj.defaultValue:obj.value;
		case 'password': return((use_default)?null:obj.value);
		case 'select-one':
			if (obj.options==null) { return null; }
			if(use_default){
				var o=obj.options;
				for(var i=0;i<o.length;i++){if(o[i].defaultSelected){return o[i].text;}}
				return o[0].text;
				}
			if (obj.selectedIndex<0){return null;}
			return(obj.options.length>0)?obj.options[obj.selectedIndex].text:null;
		case 'select-multiple': 
			if (obj.options==null) { return null; }
			var values=new Array();
			for(var i=0;i<obj.options.length;i++) {
				if((use_default&&obj.options[i].defaultSelected)||(!use_default&&obj.options[i].selected)) {
					values[values.length]=obj.options[i].text;
					}
				}
			return (values.length==0)?null:commifyArray(values,delimiter);
		}
	alert("FATAL ERROR: Field type "+obj.type+" is not supported for this function");
	return null;
	}

//-------------------------------------------------------------------
// setSingleInputValue(input_object,value)
//   Utility function used by others
//-------------------------------------------------------------------
function setSingleInputValue(obj,value) {
	switch(obj.type){
		case 'radio': case 'checkbox': if(obj.value==value){obj.checked=true;return true;}else{obj.checked=false;return false;}
		case 'text': case 'hidden': case 'textarea': case 'password': obj.value=value;return true;
		case 'select-one': case 'select-multiple': 
			var o=obj.options;
			for(var i=0;i<o.length;i++){
				if(o[i].value==value){o[i].selected=true;}
				else{o[i].selected=false;}
				}
			return true;
		}
	alert("FATAL ERROR: Field type "+obj.type+" is not supported for this function");
	return false;
	}

//-------------------------------------------------------------------
// getInputValue(input_object[,delimiter])
//   Get the value of any form input field
//   Multiple-select fields are returned as comma-separated values, or
//   delmited by the optional second argument
//   (Doesn't support input types: button,file,reset,submit)
//-------------------------------------------------------------------
function getInputValue(obj,delimiter) {
	var use_default=(arguments.length>2)?arguments[2]:false;
	if (isArray(obj) && (typeof(obj.type)=="undefined")) {
		var values=new Array();
		for(var i=0;i<obj.length;i++){
			var v=getSingleInputValue(obj[i],use_default,delimiter);
			if(v!=null){values[values.length]=v;}
			}
		return commifyArray(values,delimiter);
		}
	return getSingleInputValue(obj,use_default,delimiter);
	}

//-------------------------------------------------------------------
// getInputText(input_object[,delimiter])
//   Get the displayed text of any form input field
//   Multiple-select fields are returned as comma-separated values, or
//   delmited by the optional second argument
//   (Doesn't support input types: button,file,reset,submit)
//-------------------------------------------------------------------
function getInputText(obj,delimiter) {
	var use_default=(arguments.length>2)?arguments[2]:false;
	if (isArray(obj) && (typeof(obj.type)=="undefined")) {
		var values=new Array();
		for(var i=0;i<obj.length;i++){
			var v=getSingleInputText(obj[i],use_default,delimiter);
			if(v!=null){values[values.length]=v;}
			}
		return commifyArray(values,delimiter);
		}
	return getSingleInputText(obj,use_default,delimiter);
	}

//-------------------------------------------------------------------
// getInputDefaultValue(input_object[,delimiter])
//   Get the default value of any form input field when it was created
//   Multiple-select fields are returned as comma-separated values, or
//   delmited by the optional second argument
//   (Doesn't support input types: button,file,password,reset,submit)
//-------------------------------------------------------------------
function getInputDefaultValue(obj,delimiter){return getInputValue(obj,delimiter,true);}

//-------------------------------------------------------------------
// isChanged(input_object)
//   Returns true if input object's value has changed since it was
//   created.
//-------------------------------------------------------------------
function isChanged(obj){return(getInputValue(obj)!=getInputDefaultValue(obj));}

//-------------------------------------------------------------------
// setInputValue(obj,value)
//   Set the value of any form field. In cases where no matching value
//   is available (select, radio, etc) then no option will be selected
//   (Doesn't support input types: button,file,password,reset,submit)
//-------------------------------------------------------------------
function setInputValue(obj,value) {
	var use_default=(arguments.length>1)?arguments[1]:false;
	if(isArray(obj)&&(typeof(obj.type)=="undefined")){
		for(var i=0;i<obj.length;i++){setSingleInputValue(obj[i],value);}
		}
	else{setSingleInputValue(obj,value);}
	}

//-------------------------------------------------------------------
// InputNumbersOnly(myfield, e, dec)
//   Only numbers are allowed in a textbox.
//   Example on the HTML page:
//     <INPUT NAME="dollar" SIZE=5 MAXLENGTH=5 onKeyPress="return InputNumbersOnly(this, event)">
//-------------------------------------------------------------------
function InputNumbersOnly(myfield, e, dec)
{
    var key;
    var keychar;

    if (window.event)
        key = window.event.keyCode;
    else 
    {   if (e)
            key = e.which;
        else
            return true;
    }
    
    keychar = String.fromCharCode(key);
    
    // control keys
    if ((key==null) || (key==0) || (key==8) || (key==9) || (key==13) || (key==27) )
    {   event.cancelBubble = true;	
        event.returnValue = true;
        return true;
    }
    else // numbers
    {
        if ((("0123456789").indexOf(keychar) > -1))
        {
            event.cancelBubble = true;	
            event.returnValue = true;
            return true;
        }    
        else
        {   event.cancelBubble = true;	
            event.returnValue = false;
            return false;
        }        
    }
}

	
	
//-------------------------------------------------------------------
// isFormModified(form_object,hidden_fields,ignore_fields)
//   Check to see if anything in a form has been changed. By default
//   it will check all visible form elements and ignore all hidden 
//   fields. 
//   You can pass a comma-separated list of field names to check in
//   addition to visible fields (for hiddens, etc).
//   You can also pass a comma-separated list of field names to be
//   ignored in the check.
//-------------------------------------------------------------------
function isFormModified(theform,hidden_fields,ignore_fields){
	if(hidden_fields==null){hidden_fields="";}
	if(ignore_fields==null){ignore_fields="";}
	var hiddenFields=new Object();
	var ignoreFields=new Object();
	var i,field;
	var hidden_fields_array=hidden_fields.split(',');
	for (i=0;i<hidden_fields_array.length;i++) {
		hiddenFields[Trim(hidden_fields_array[i])]=true;
		}
	var ignore_fields_array=ignore_fields.split(',');
	for (i=0;i<ignore_fields_array.length;i++) {
		ignoreFields[Trim(ignore_fields_array[i])]=true;
		}
	for (i=0;i<theform.elements.length;i++) {
		var changed=false;
		var name=theform.elements[i].name;
		if(!isBlank(name)){
			var type=theform[name].type;
			if(!ignoreFields[name]){
				if(type=="hidden"&&hiddenFields[name]){changed=isChanged(theform[name]);}
				else if(type=="hidden"){changed=false;}
				else {changed=isChanged(theform[name]);}
				}
			}
		if(changed){return true;}
		}
		return false;
	}


////////////////////////////////////////////////////////////////////////////////////////////
//
//  --------------------------------------------------------------
//      W I N D O W    F U N C T I O N S 
//  --------------------------------------------------------------
//  


///-----------------------------------------------------------------------------------------------
///
///  Open a new window and check for popup blocker.
///  For full list of parameters check http://msdn2.microsoft.com/en-us/library/ms536651.aspx
///     
///  location = { yes | no | 1 | 0 }
///  menubar = { yes | no | 1 | 0 }
///  resizable = { yes | no | 1 | 0 }
///  scrollbars = { yes | no | 1 | 0 }
///  status = { yes | no | 1 | 0 }
///  titlebar = { yes | no | 1 | 0 }
///  toolbar = { yes | no | 1 | 0 }
///  top = number
///  width = number
///  height = number
///  left = number
///  fullscreen = { yes | no | 1 | 0 }
///
///  Example:
///  WindowOpen("Sample.htm",800, 600, "status=yes,toolbar=no,menubar=no,location=no", "Test");
///
///-----------------------------------------------------------------------------------------------
function WindowOpen( url, width, height, opt , name ) 
{
    if (width==null) width=640;
    if (height==null) height=480;
    if (opt==null) opt="";
    if (name==null) name="";
    
    var win = window.open( url, name.replace("-",""), "width=" + width + ",height=" + height + "," + opt);
    if (!win)
        alert("We have detected that you are using popup blocking software.\nTurn off the popup blocker and try it again.");     
    else
        win.focus()
}

function PostBackOpener() {
    try {
        window.opener.execScript("__doPostBack('PostBackOpener', '')","JavaScript");
    }
    catch (e) {}
    return true;
}
function RefreshOpener() {
    try {
        window.opener.location.href = window.opener.location.href;
    }
    catch (e) {}
    return true;
}
function FocusOpener() {
    try {
        window.opener.focus();
    }
    catch (e) {}
    return true;
}
function FocusSelf() {
    window.focus();
}

////////////////////////////////////////////////////////////////////////////////////////////
//
//  ----------------------------------------------------------------------------------------
//  B R O W S E R   D E T E C T I O N   F U N C T I O N S 
//  ----------------------------------------------------------------------------------------
//  isMac = (navigator.appVersion.indexOf(”Mac”)!=-1) ? true : false;
//  NS4 = (document.layers) ? true : false;
//  IEmac = ((document.all)&&(isMac)) ? true : false;
//  IE4plus = (document.all) ? true : false;
//  IE4 = ((document.all)&&(navigator.appVersion.indexOf(”MSIE 4.”)!=-1)) ? true : false;
//  IE5 = ((document.all)&&(navigator.appVersion.indexOf(”MSIE 5.”)!=-1)) ? true : false;
//  IE6 = ((document.all)&&(navigator.appVersion.indexOf(”MSIE 6.”)!=-1)) ? true : false;
//  IE7 = ((document.all)&&(navigator.appVersion.indexOf(”MSIE 7.”)!=-1)) ? true : false;
//  ver4 = (NS4 || IE4plus) ? true : false;
//  NS6 = (!document.layers) && (navigator.userAgent.indexOf(’Netscape’)!=-1)?true:false;
// 

function isBrowserLegacy()
{
    if (window.XMLHttpRequest) {
        return false; // IE 7, mozilla, safari, opera 9
    } else {
        return true; // IE6, older browsers
    }
}
function isIE()
{
    var isIEv = false
    if(navigator.appName.indexOf("Internet Explorer") != -1)
        isIEv = true;
    
    return isIEv;
}

function IEVersion()
{
    var version = 0;
    if(navigator.appName.indexOf("Internet Explorer") != -1) {
        var temp = navigator.appVersion.split("MSIE");
        version = parseFloat(temp[1]);
    }
    return version;  //NON IE browser will return 0
}


/////////////////////////////////////////////////////////////////////////////////////////////
//
//  ----------------------------------------------------------------------------------------
//  E V E N T    F U N C T I O N S 
//  ----------------------------------------------------------------------------------------

function AttachEvent(objID, evt, fnc, useCapture) {
    var obj = MM_findObj(objID);

	if (!useCapture) useCapture=false;
	
	try
	{
		obj.addEventListener(evt,fnc,useCapture);
		return true;
	} 
	catch(err)
	{  
        if (isIE()) 
        {
            return obj.attachEvent("on"+evt,fnc);
            
	    }
	    else
	    {
		    MyAttachEvent(obj,evt,fnc);
		    obj['on'+evt]=function(){ MyFireEvent(obj,evt)}; 
		}
	}
} 

//The following are for browsers like NS4 or IE5Mac which don't support either
//attachEvent or addEventListener
function MyAttachEvent(obj,evt,fnc){
	if (!obj.myEvents) obj.myEvents={};
	if (!obj.myEvents[evt]) obj.myEvents[evt]=[];
	var evts = obj.myEvents[evt];
	evts[evts.length]=fnc;
}

function MyFireEvent(obj,evt){
	if (!obj || !obj.myEvents || !obj.myEvents[evt]) return;
	var evts = obj.myEvents[evt];
	for (var i=0,len=evts.length;i<len;i++) evts[i]();
}


function findPosObj(obj)
{
	var curleft = curtop = 0;
	if (obj.offsetParent) {
		curleft = obj.offsetLeft;
		curtop = obj.offsetTop;
		while (obj = obj.offsetParent) {
			curleft += obj.offsetLeft;
			curtop += obj.offsetTop;
		}
	}
	return [curleft,curtop];
}

function findPosName(objname)
{
    obj = MM_findObj(objname);
	var curleft = curtop = 0;
	if (obj.offsetParent) {
		curleft = obj.offsetLeft;
		curtop = obj.offsetTop;
		while (obj = obj.offsetParent) {
			curleft += obj.offsetLeft;
			curtop += obj.offsetTop;
		}
	}
	return [curleft,curtop];
}

function PopupExt(src)
{   
    document.all.masterIframe.src=src;
    $find('MPE').show();
}

/////////////////////////////////////////////////////////////////////////////////////////////
//
//  ----------------------------------------------------------------------------------------
//  S U B M I T   F O R M   W H E N    E N T E R   K E Y   I S   P R E S S E D 
//  ----------------------------------------------------------------------------------------
//  the purpose of this function is to allow the enter key to 
//  point to the correct button to click.
//  
//  On the ASP.NET code behide, attached the event as follows
//
//  if (!IsPostBack)
//  {
//      txtName.Attributes.Add("onkeypress", "doClick('" + imgGoGS.ClientID + "',event)");   // imgGoGS is the button press when user press ENTER
//  }
//
//
function doClick(buttonName,e)
{
    var key;

    if(window.event)
        key = window.event.keyCode;     //IE
    else
        key = e.which;                  //firefox

    if (key == 13)
    {
        //Get the button the user wants to have clicked
        var btn = document.getElementById(buttonName);
        if (btn != null)
        { //If we find the button click it
            btn.click();
            event.keyCode = 0
        }
    }
}

function trim(str, chars) {
    return ltrim(rtrim(str, chars), chars);
}

function ltrim(str, chars) {
    chars = chars || "\\s";
    return str.replace(new RegExp("^[" + chars + "]+", "g"), "");
}

function rtrim(str, chars) {
    chars = chars || "\\s";
    return str.replace(new RegExp("[" + chars + "]+$", "g"), "");
}