function setSelectOption(theSelect, theValue)
 {
   for (var i = 0; i < theSelect.length; i++)
    {
       if (theSelect.options[i].value == theValue)
        {
          theSelect.selectedIndex = i;
          return;
        }
    }
   theSelect.selectedIndex = 0;
   return;
 }

/** compare with text of option not value */
function setSelectOptionText(theSelect, theValue)
 {
   for (var i = 0; i < theSelect.length; i++)
    {
       if (theSelect.options[i].text.toLowerCase() == theValue.toLowerCase())
        {
          theSelect.selectedIndex = i;
          return;
        }
    }
   theSelect.selectedIndex = 0;
   return;
 }

//************************************************
// getSelectedCheckBoxColumnValues
//
// inputs:     form - A form object
//        colName - Name of the hidden field  that you want to mine
//        sep - A separator string such as , or |
// what does it do:
//     1. Expects every checkbox to be named as: 1,2,3,4..
//    2. Expects a hidden field for every checkbox name: r1_coname, r2_colname
//    3. For every check box that is checked, it will collect the values for those hidden fields
//    4. For ex: if checkbox "2" is checked then "r2_colname' will be mined
//    5. Mined column values will be returned as val1|val2|val3
// Limitations
//    1. Doesn't work very well if a certain field is empty
//    2. Recommendation would be to use something like "None" or "Empty" to recognize these fields
//    3. Does not allow anyother checkboxes in the form
// Remedies
//     1. Use instead one of the following functions
//    2. getSelectedCheckBoxHiddenValues
//    3. getSelectedColumnValues
// comments:
//
//        deprecated
//        Use instead getSelectedCheckBoxHiddenValues
//        or getSelectedCheckBoxValues
//******************************************************
function getSelectedCheckBoxColumnValues(form, colName, sep)
{
    var selectedUsers = "";
    elementArray = form.elements;
    for(i=0;i<elementArray.length;i++)
    {
        element = elementArray[i];
        if (element.type == "checkbox")
        {
            if (element.checked == true)
            {
                // Let's get the value of the column
                checkBoxName = element.name;

                // There must be an input hidden field with this name
                // checkBoxName_colName
                colFieldName = "form.r" + checkBoxName + "_" + colName;
                
                var colField = eval(colFieldName);
                colFieldValue = colField.value;
                if (selectedUsers != "")
                {
                    selectedUsers = selectedUsers + sep + colFieldValue;
                }
                else
                {
                    selectedUsers = colFieldValue;
                }
            }
        }
    }
    return selectedUsers;
}

//************************************************
// getSelectedColumnValues
//
// inputs:     form - A form object
//        colName - Name of the hidden field  that you want to mine
//        sep - A separator string such as , or |
// what does it do:
//     1. Expects tabular checkboxs to be named as: rownum
//    2. These checkboxes values need to be set to : 1,2,3
//    2. Expects a hidden field for every checkbox value: r1_coname, r2_colname
//    3. For every "rownum" named check box that is checked, 
//        it will collect the values for those hidden fields
//    4. For ex: if checkbox whose value is "2" is checked then "r2_colname' will be mined
//    5. Mined column values will be returned as val1|val2|val3
// Limitations
//    1. Doesn't work very well if a certain field is empty
//    2. Recommendation would be to use something like "None" or "Empty" to recognize these fields
// Remedies
//     1. Potentially another version of this should be used that will take an array
//        and fill the empty ones with spaces.
//    2. getSelectedCheckBoxHiddenValues
//    3. getSelectedColumnValues
//******************************************************
function getSelectedColumnValues(form, colName, sep)
{
    var selectedUsers = "";
    elementArray = form.elements;
    for(i=0;i<elementArray.length;i++)
    {
        element = elementArray[i];
        if (element.type != "checkbox")
            continue;
        if (element.name != "rownum")
            continue;
        if (element.checked != true)
            continue;

        // Let's get the value of the column
        checkBoxValue = element.value;

        // There must be an input hidden field with this name
        // checkBoxName_colName
        colFieldName = "form.r" + checkBoxValue + "_" + colName;
        
        var colField = eval(colFieldName);
        colFieldValue = colField.value;
    
        if (selectedUsers != "")
        {
            selectedUsers = selectedUsers + sep + colFieldValue;
        }
        else
        {
            selectedUsers = colFieldValue;
        }
    }
    return selectedUsers;
}

//************************************************
// getSelectedColumnValuesAsArray
//
// inputs:     form - A form object
//        colName - Name of the hidden field  that you want to mine
//        sep - A separator string such as , or |
// what does it do:
//     1. Expects tabular checkboxs to be named as: rownum
//    2. These checkboxes values need to be set to : 1,2,3
//    2. Expects a hidden field for every checkbox value: r1_coname, r2_colname
//    3. For every "rownum" named check box that is checked, 
//        it will collect the values for those hidden fields
//    4. For ex: if checkbox whose value is "2" is checked then "r2_colname' will be mined
//    5. Mined column values will be returned as a zero index based array
//******************************************************
function getSelectedColumnValuesAsArray(form, colName)
{
    var colValueArray= new Array();
    elementArray = form.elements;
    index = 0;
    for(i=0;i<elementArray.length;i++)
    {
        element = elementArray[i];
        if (element.type != "checkbox")
            continue;
        if (element.name != "rownum")
            continue;
        if (element.checked != true)
            continue;

        // Let's get the value of the column
        checkBoxValue = element.value;

        // There must be an input hidden field with this name
        // checkBoxName_colName
        colFieldName = "form.r" + checkBoxValue + "_" + colName;
        
        var colField = eval(colFieldName);
        colFieldValue = colField.value;  
        colValueArray[index]=colFieldValue;
    }
    return colValueArray;
}

//************************************************
// getSelectedCheckBoxValues
//
// inputs:     form - A form object
//        colName - Name of the hidden field  that you want to mine
//        sep - A separator string such as , or |
//************************************************
function getSelectedCheckBoxValues(form, colName, sep)
{
    var selectedUsers = "";
    elementArray = form.elements;
    for(i=0;i<elementArray.length;i++)
    {
        element = elementArray[i];
        if (element.name != colName)
        {
            continue;
        }
        if (element.type == "checkbox")
        {
            if (element.checked == true)
            {

                // Let's get the value of the column

                // There must be an input hidden field with this name
                // checkBoxName_colName
                checkBoxValue = element.value;

                if (selectedUsers != "")
                {
                    selectedUsers = selectedUsers + sep + checkBoxValue;
                }
                else
                {
                    selectedUsers = checkBoxValue;
                }
            }
        }
    }
    return selectedUsers;
}

//************************************************
// getUnSelectedCheckBoxValues
//
// inputs:     form - A form object
//        colName - Name of the hidden field  that you want to mine
//        sep - A separator string such as , or |
//************************************************
function getUnSelectedCheckBoxValues(form, colName, sep)
{
    var selectedUsers = "";
    elementArray = form.elements;
    for(i=0;i<elementArray.length;i++)
    {
        element = elementArray[i];
        if (element.name != colName)
        {
            continue;
        }
        if (element.type == "checkbox")
        {
            if (element.checked == false)
            {


                // There must be an input hidden field with this name
                // checkBoxName_colName
                checkBoxValue = element.value;

                if (selectedUsers != "")
                {
                    selectedUsers = selectedUsers + sep + checkBoxValue;
                }
                else
                {
                    selectedUsers = checkBoxValue;
                }
            }
        }
    }
    return selectedUsers;
}

//************************************************
// getSelectedCheckBoxes in a form
//
// inputs:     form object
//        A separator string such as , or |
//************************************************

function getSelectedCheckBoxes(form, sep)
{
    var selectedUsers = "";
    elementArray = form.elements;
    for(i=0;i<elementArray.length;i++)
    {
        element = elementArray[i];
        if (element.type == "checkbox")
        {
            if (element.checked == true)
            {
                if (selectedUsers != "")
                {
                    selectedUsers = selectedUsers + sep + element.name;
                }
                else
                {
                    selectedUsers = element.name;
                }
            }
        }
    }
    return selectedUsers;
}

//************************************************
// quick and easy way to work with select objects
//
// inputs:     select object
//        return selected option or value
//************************************************
function getOptionString(selectObject)
{
    selOption = selectObject.options[selectObject.selectedIndex];
    return selOption.text;
}
function getValueString(selectObject)
{
    selOption = selectObject.options[selectObject.selectedIndex];
    return selOption.value;
}

//************************************************
// Given a set of fields return their values if they are not empty
//
// inputs:     form object
//        comma separated field names in that form
//************************************************
function getFieldValues(form,fieldNames)
{
   if (fieldNames == "")
   {
      return "";
   }
   fieldNameArray = fieldNames.split(",");
   fieldValues = "";
   for(i=0;i<fieldNameArray.length;i++)
   {
      fieldName = fieldNameArray[i];
      fieldObj = eval("form." + fieldName );
      fieldValue = fieldObj.value;
    fieldType = fieldObj.type;

    if (fieldType != "button" && fieldType != "hidden")
    {
        if (fieldValues == "")
        {
            fieldValues = fieldName + "=" + escape(fieldValue);
        }
        else
        {
            fieldValues += "&" + fieldName + "=" + escape(fieldValue);
        }
    }
   }
    return fieldValues;
}

//************************************************
// Given a set of fields return their values if they are not empty
//
// inputs:     form object
//        comma separated field names in that form
//************************************************
function getFieldValuesAsAWhereClause(form,fieldNames,columnNames, colTypes, nullColumnValue)
{
   if (fieldNames == "")
   {
      return "";
   }
   fieldNameArray = fieldNames.split(",");
   columnNameArray = columnNames.split(",");
   colTypesArray = colTypes.split(",");

   if (fieldNameArray.length != columnNameArray.length)
   {
    alert("Error: Number of fieldNames and columnNames do not match");
    return;
   }
   whereClause = "";
   for(i=0;i<fieldNameArray.length;i++)
   {
      fieldName = fieldNameArray[i];
    columnName = columnNameArray[i];
    colType = colTypesArray[i];
      fieldObj = eval("form." + fieldName );
      fieldValue = fieldObj.value;
    fieldType = fieldObj.type;


    if (fieldType != "button" && fieldType != "hidden")
    {
        curWhereClauseField = getWhereClauseForField(columnName,fieldValue,colType,nullColumnValue);
        if (curWhereClauseField == "")
            continue;
        if (whereClause == "")
        {
            whereClause = curWhereClauseField;
        }
        else
        {
            whereClause += " and " + curWhereClauseField;
        }
    }
   }
    return whereClause;
}

function getWhereClauseForField(columnName, colValue, colType,nullColumnValue)
{
    if (colValue == "")
    {
        return "";
    }
    if (colValue == nullColumnValue)
    {
        return "";
    }
    else
    {
        if (colValue.indexOf('*') != -1)
        {
            // there is a wild card in it
            return columnName + " like '" + colValue + "'";
        }
        else if (colValue.indexOf('%') != -1)
        {
            return columnName + " like '" + colValue + "'";
        }
        if (colType == "string")
        {
            return columnName + " = '" + colValue + "'";
        }
        else
        {
            return columnName + " = " + colValue;
        }
    }
}

function getAllFieldValues(form)
{
    // for each element
    fieldValues = "";
   for(i=0;i<form.elements.length;i++)
   {
    element = form.elements[i];
      fieldName = element.name;
      fieldValue = element.value;
    fieldType = element.type;

    if (fieldType != "button" && fieldType != "hidden")
    {
        if (fieldValues == "")
        {
            fieldValues = fieldName + "=" + escape(fieldValue);
        }
        else
        {
            fieldValues += "&" + fieldName + "=" + escape(fieldValue);
        }
    }
   }
   return fieldValues;
}

function setFieldValues(form, fieldValueString)
{

    if(fieldValueString == "")
       return;
    fieldValueArray = fieldValueString.split("&");
    for (i=0; i<fieldValueArray.length;i++)
    {
        fieldValuePair = fieldValueArray[i].split("=");
        fieldName = fieldValuePair[0];
        fieldValue = "";
        if (fieldValuePair.length > 1)
        {
            fieldValue = unescape(fieldValuePair[1]);
        }
        var objname = eval("form." + fieldName);
        if(objname)
        {
           fieldObj = objname;//eval("form." + fieldName );
		var oldValue = fieldObj.value;
           fieldObj.value = fieldValue;
		if(!fieldObj.value) // if value is passed in as empty space, then the value of the current page is populated.
			fieldObj.value = oldValue;
        }
    }
}


//************************************************
// required field validations for a form
//
// inputs:     form object
//        comma separated field names in that form
//************************************************
function validateRequired(form,fieldNames)
{
   if (fieldNames == "")
   {
      return true;
   }
   fieldNameArray = fieldNames.split(",");
   for(i=0;i<fieldNameArray.length;i++)
   {
      fieldName = fieldNameArray[i];
      fieldObj = eval("form." + fieldName );
      fieldValue = fieldObj.value;
      if (fieldValue == "")
      {
         alert("'" + fieldName + "' is a required field" );
         fieldObj.focus();
         return false;
      }
   }
   return true;
}

//************************************************
// ReqExp support for field validations
//
//************************************************
//  Include the following line on your page
//  var typeArray = createTypeArray();
//

//************************************************
// An internal function used by regexp support
//************************************************
function createFieldType(fieldTypeName, regExp, fieldMessage )
{
    this.fieldTypeName = fieldTypeName;
    this.regExp = new RegExp(regExp);
    this.fieldMessage = fieldMessage;
    return this;
}


function validateField(fieldObj, inFieldType)
{
    fieldValue = fieldObj.value;
    if (fieldValue == "") return new Boolean(true);

    var fieldType  = typeArray[inFieldType];
    if (fieldType.regExp.test(fieldValue) == false)
    {
        line1 = "You have typed : '" + fieldValue + "' for " + inFieldType;
        line2 = fieldType.fieldMessage;
        alert(line1 + "\n" + line2);
        fieldObj.focus();
        return new Boolean(false);
    }
    return new Boolean(true);
}

//************************************************
// Validate field content based on pre-defined fieldtypes.
//
// inputs:     form object
//        comma separated fieldNameAndType strings
// returns: true/false
// ex:  validateForContent(thisForm,"field1|field1Type,field2|field2Type")
//************************************************
function validateForContent(form,fieldNames)
{
   if (fieldNames == "")
   {
      return true;
   }
   fieldNameArray = fieldNames.split(",");
   for(i=0;i<fieldNameArray.length;i++)
   {
      fieldNameAndType = fieldNameArray[i];

    // Get field name and type
    fieldNameAndTypeArray = fieldNameAndType.split("|");
    fieldName = fieldNameAndTypeArray[0];
    fieldType = fieldNameAndTypeArray[1];

    // Get field object & value
      fieldObj = eval("form." + fieldName );
    
    if (validateField(fieldObj,fieldType) == false)
    {
        return false;
    }
   }
   return true;
}

function validateEmail(myEmail) 
{

  var exclude=/[^@\-\.\w]|^[@\.\-]|[\.\-]{2}|[@\.]{2}|(@)[^@]*\1/;
  var check=/@[\w\-]+\./;
  var checkend=/\.[a-zA-Z]{2,3}$/;

  if(((myEmail.value.search(exclude) != -1)||(myEmail.value.search(check)) == -1)||(myEmail.value.search(checkend) == -1))
  {
    return false;
  }
  else 
  {
     return true;;
  }
}

/**
 * alert(validateStringForCharacter('ABC"', '"'));
 */
function validateStringForCharacter(inputStr, inputchar) 
{

  var inputcharregexp = new RegExp(inputchar, "g");

  if(inputStr.search(inputcharregexp ) != -1)
  {
    return true;
  }
  else 
  {
     return false;
  }
}

//************************************************
//edits numeric range
//************************************************
 function numericRange(myField, myRequired, myTypeInteger, myMin, myMax)
 {
   // input myfield the element to edit
   // boolean myRequired  true = required
   // boolean myTypeInteger true = must be integer
   // number  myMin  cannot be less than
   // number  myMax  cannot be > than
   //
   
   if (isEmpty(myField))
    { if (myRequired)
       {
         alert(myField.name + " must be entered");
         myField.focus();
         return false;
       }
       else
       {  
         return true;
       }
    }
       
    if (isNaN(myField.value))
    {   
       alert(myField.name + " must be numeric");
       myField.focus();
       return false;
    }

    workNum = parseFloat(myField.value);
    if (workNum < myMin)
    {   
        alert(myField.name + " cannot be less than " + myMin);
        myField.focus();
        return false;
    }
     
    if (workNum > myMax)
    {
        alert(myField.name + " cannot be greater than " + myMax);
        myField.focus();
        return false;
    }
    
    if (myTypeInteger)
    {   
        if (myField.value.indexOf(".",0) > -1)
        {
          alert(myField.name + " cannot contain a decimal point");
          myField.focus();
          return false;
        }  
    }
    if (myTypeInteger)
    {   
        if (myField.value.indexOf(" ",0) > -1)
        {
          alert(myField.name + " cannot contain embedded spaces");
          myField.focus();
          return false;
        }  
    }
    return true;
 }

//************************************************
//edits for productom.htlm
//************************************************

function isEmpty(myField) 
{
 //trim(myField);
 if (myField.value == "") 
 {
    return true;
 }
 else
 {
    return false;
 }
}

function trim(input2)
{
var a=input2.value;

var regexp=/\s*/    //Removes all leading whitespace
var regexp1=/\s*$/  //Removes all trailing whitespace

a=a.replace(regexp,"");
a=a.replace(regexp1,"");
input2.value=a;
}

function transformToNewLines(lines)
{
    splitLines = lines.split("\n");
    updatedLine = "";
    for(i=0;i<splitLines.length;i++)
    {
        updatedLine += splitLines[i];
        updatedLine += "\\n";
    }
    return updatedLine;
}

function transformFromNewLines(lines)
{
    splitLines = lines.split("\\n");
    updatedLine = "";
    for(i=0;i<splitLines.length;i++)
    {
        updatedLine += splitLines[i];
        updatedLine += "\n";
    }
    return updatedLine;
}


//calibrate codes
function createTypeArray()
{
	typeArray = new Array();
	typeArray.arzCode = new createFieldType("arzCode","^\\w{6}$","ARZ Code is alphanumeric and 6 characters wide");
	typeArray.scac = new createFieldType("scac","^\\w{0,4}$","ARZ Code is alphanumeric and 6 characters wide");
//	typeArray.positiveNumber = new createFieldType("positiveNumber","\\d*|.?","Positive Number");
	typeArray.positiveInteger4 = new createFieldType("Pixel","^\\d{1,4}$","Positive Integer of length 4");
	typeArray.positiveNumber = new createFieldType("Distance","^\\d{1,5}\.{0,1}\\d{0,2}$","Positive Number with at most two decimals");


//	typeArray.positiveNumber = new createFieldType("positiveNumber","^\\d*\.?$","Positive Number");
	
	return typeArray;
}

/** new codes from Hoai
 */

/* allow only characters and numbers */
function isAlphaNumeric(val)
{
	var exp = /^[A-Za-z0-9]+$/;
	
	if(val.search(exp) == -1)
	{
//		alert("Entered value is not valid.");
		return false;
	}
	
	return true;
}

function excludeReserveChars(field)
{
	var frm = document.forms[0];

	var exp = /^[A-Za-z0-9]+$/;
	var exclude=/[\"\'\?\@\!\~\`\%\^\*\(\)\=]/;	

	if(field.value.search(exclude) >= 0)
	{
		alert("Entered value is not valid.  Characters like .,',\" are not allowed.");
		field.focus();
		return false;
	}
	return true;
}

function excludeReserveChars2(field)
{
	var frm = document.forms[0];

	var exp = /^[A-Za-z0-9]+$/;
	var exclude=/[\"\']/;	

	if(field.value.search(exclude) >= 0)
	{
		alert("Characters like single quote and double quote are not allowed.");
		field.focus();
		return false;
	}
	return true;
}

function removeATag(str)
{
	var index1 = -1;
	var index2 = -1;
	var index3 = -1
	var newStr = "";
	
	index1 = str.indexOf("<a");
	index2 = str.indexOf(">");
	index3 = str.indexOf("</a>");
	
	if(index2 < 0 || index3 < 0 || index1 < 0)
		return false;
			
	newStr = str.substring(0,index1);
	newStr += str.substring(index2+1,index3);
	newStr += str.substring(index3+4, str.length);
	
	return newStr;
	
}



/** put extra zero if number has less than three digits */
function concatenateZeros(inputVal,numbDigit)
{
	var val = inputVal.length;
	var zeroN = numbDigit - val;
	for(var i=0; i<zeroN; i++)
	{
		inputVal = "0" + inputVal;
	}
	return inputVal;
}


/**General function for dosubmit **/

function dosubmit(frm,url,pagename) 
{
 frm.aspireURL.value = url; 
 frm.aspireAction.value="select";
 frm.method="POST"; 
 frm.submit(); 
 }

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

	THis function will support hyperlink submissions in jetspeed.  Href must look like: 

	<a href="javascript:doSubmitURL(<jetspeed:portletlink>,document.formName,otherParams)">

	where an example of otherParams = "param1=22&param2=45&paramA=and"

NOT USED
********************/
function doSubmitURL(url, frm, aspireURL, params)
{
	if(url == "" || frm == null) return;
	if(frm == "" || frm == null) return;
	frm.action = url;
	alert("URL = " + frm.action);
	frm.aspireURL.value = aspireURL; 
 	frm.aspireAction.value="select";
 	frm.method="POST"; 
 	frm.submit();
}


function doupdatesubmit(frm,url,pagename) 
{  
 frm.aspireURL.value = url; 
 frm.aspireAction.value="update";
 frm.method="POST"; 
 frm.submit(); 
 }

function dosubupdatesubmit(frm,url,pagename,msg,disdoc) 
{  
 alert(msg);
 frm.aspireURL.value = url; 
 frm.aspireAction.value="update";
 frm.disdoc.value=disdoc;
 frm.method="POST"; 
 frm.submit(); 
 }

/** Frame JS **/
function doFrameSubmit(frm,nurl)
{
frm.action="/content/servlet/DisplayServlet?url="+nurl; 
frm.method="post";
frm.submit();
}


function doFrameSubmit2(frm,url,jetspeed)
{
frm.aspireURL.value = url; 
frm.aspireAction.value="select";
if(jetspeed=="false") frm.action="/content/servlet/DisplayServlet?url="+url; 
frm.method="post";
frm.submit();
}


function doUpdate(frm,url,jetspeed)
{
frm.aspireURL.value = url; 
frm.aspireAction.value="update";
if(jetspeed=="false") frm.action="/content/servlet/UpdateServlet?request_name="+url; 
frm.method="post";
frm.submit();
}

function doSubcribeSubmit(frm,url,msg,disdoc,jetspeed) 
{  
 alert(msg);
 frm.disdoc.value=disdoc;
 doUpdate(frm,url,jetspeed);
 }

function dosubFrameupdatesubmit(frm,url,msg,disdoc) 
{  
 alert(msg);
 frm.disdoc.value=disdoc;
 frm.action="/content/servlet/UpdateServlet?request_name="+url; 
 frm.method="POST"; 
 frm.submit(); 
 }

function doUpdateFrameSubmit(frm,nurl)
{
frm.action="/content/servlet/UpdateServlet?request_name="+nurl; 
frm.method="post";
frm.submit();
}

function checkFromToDate(fromdate,todate)
{
	var fromyyyy=fromdate.substring(0,4);
	var frommm=fromdate.substring(5,7);
	var fromdd=fromdate.substring(8,10);

	var toyyyy=todate.substring(0,4);
	var tomm=todate.substring(5,7);
	var todd=todate.substring(8,10);

	var chdate1=new Date(fromyyyy,frommm,fromdd);
	var chdate2=new Date(toyyyy,tomm,todd);

	if(chdate1>chdate2)
	{
	 alert("Enter appropriate end date");
	 return(false);
	}

 return true;
}

function checkDateWithNow(chkdate,hr,min,am)
{
	var yyyy=chkdate.substring(0,4);
	var mm=chkdate.substring(5,7);
	var dd=chkdate.substring(8,10);
	
	var y=(new Date()).getFullYear();
	var m=(new Date()).getMonth();
	var d=(new Date()).getDate();
	var nowhr = (new Date()).getHours();
	var nowmin = (new Date()).getMinutes();


	if(am == "pm")
	{
	   if(hr != "12") 
 		hr = (hr-0)+12;
	}

	var chdate1=new Date(yyyy,mm-1,dd,hr,min);
	var chdate2=new Date(y,m,d,nowhr,nowmin);

	if(chdate1<chdate2) //check for current date
	{
	 alert("You cannot schedule an event in the past");
	       return(false);
	}
	else
	  return(true);
}

function putBR(result)
{
	var str = result; 
	for(i=0; i<str.length; i++){ 
		if(str.indexOf("%0D%0A") > -1){ 
			str=str.replace("%0D%0A",'<br>');
		}
		else if(str.indexOf("%0A") > -1){ 
			str=str.replace("%0A",'<br>');
		}
		else if(str.indexOf("+") > -1){ 
			str=str.replace("+",' ');
		}
		else if(str.indexOf("%09") > -1){ 
			str=str.replace("%09",'');
		}
		else if(str.indexOf("%2C") > -1){ 
		str=str.replace("%2C",',');
		}
		else if(str.indexOf("%2F") > -1){ 
		str=str.replace("%2F",'/');
		}


	}
	return str;
}

// Created by Yayati to validate Folder name

function validateFolderName(inputfield)
{
	var exclude= /[\/\\\:\*\?\<\>\|]/;
	if(inputfield.value.search(exclude) >= 0)
	{
		alert("Entered value is not valid.  Characters like //,*,<,>,:,|,? are not allowed in Folder Name.");
		inputfield.focus();
		return false;
	}
	return true;
}

// Created by Yayati to validate File name

function validateFileName(inputfield)
{
	var exclude= /[\*\?\<\>\|]/;
	if(inputfield.value.search(exclude) >= 0)
	{
		alert("Entered value is not valid.  Characters like *,<,>,|,? are not allowed in File Name");
		inputfield.focus();
		return false;
	}
	return true;
}

//
function chkGlobalEnter(frm,url,evt,jetspeed) { 
 evt  = (evt) ? evt : event;
 var charCode = (evt.which) ? evt.which : evt.keyCode;
 if(charCode == 13) {
 if(top.isEmpty(frm.search)){	
	  alert("Enter keyword for search");
	  evt.returnValue=false;
      evt.cancel = true;
    } else {
    top.doFrameSubmit2(frm,url,jetspeed);
	}
 }
} 


function doPageSubmit(frm, pid, jetspeed)
{
//var frm=document.listpages;
frm.page_id.value=pid;
top.doFrameSubmit2(frm,'DisplayCoursePageDetails',jetspeed);
}


function chkStartDateWithNow(chkdate) {
	var yyyy=chkdate.substring(0,4);
	var mm=chkdate.substring(5,7);
	var dd=chkdate.substring(8,10);
	
	var y=(new Date()).getFullYear();
	var m=(new Date()).getMonth();
	var d=(new Date()).getDate();

	var chdate1=new Date(yyyy,mm-1,dd);
	var chdate2=new Date(y,m,d);

	if(chdate1<chdate2) //check for current date
	{
	 alert("You cannot select a date in past.");
	       return(false);
	}
	else
	  return(true);
}