//********************** JAVA SCRIPT LIBRARY ************************************************
//****** Project : Lender Online System              ****************************************
//******  Legend :                           Ex:                                *************
//******           Global Variables -->           "global_Variable" or "global" *************
//******            Local Variables -->           "_localVariable" or "_local"  *************
//******                  Functions -->           "functionName"                *************
//******                    Objects -->           "ObjectName"                  *************
//******       Non-Object Parameter -->           "prmName"                     *************


//**** Str      <--     String
//**** Char     <--     Character
//**** Nbr      <--     Number

//**** Img      <--     Image
//**** Btn      <--     Button
//**** Obj      <--     Object

//**** Del      <--     Delete
//**** Val      <--     Value
//**** Prm      <--     Parameter
//**** Pos      <--     Position
//**** Sel      <--     Selected
//**** Len      <--     Length
//**** Rep      <--     Repeated
//**** Req      <--     Required
//**** Rec      <--     Record
//**** Fld      <--     Field


//*******************************************************************************************
//*************************   GLOBAL VARIABLES    *******************************************
//*******************************************************************************************

//**************** DATES ********************************************************************
var date_Saver;

//**************** IMAGES *******************************************************************
var img_Folder = "../../Images/";

var img_End = new Array(3);
       img_End[0] = "-img1.gif";
       img_End[1] = "-img2.gif";  
           img_End[2] = "-img3.gif";  
           
var img_Sel = "";

//**************** INTERVAL FUNCTIONS *******************************************************
var interval_ID;

//**************** FORMS ********************************************************************
var nav_IE = document.all ? 1 : 0;
var nav_Netscape = navigator.appName=="Netscape" ? 1 : 0;

var prior_ListObj;
          
//*******************************************************************************************
//*************************                   ***********************************************
//*************************     FUNCTIONS     ***********************************************
//*************************                   ***********************************************
//*******************************************************************************************

//*******************************************************************************************
//*************************   CONSTRUCTORS    ***********************************************
//*******************************************************************************************

//************************* Date Constructor ********************************************
function dateObjConstructor(prmDateStr)
{
   var _firstSlash = prmDateStr.indexOf("/");
   var _secondSlash = prmDateStr.lastIndexOf("/");
   
   this.MonthStr = prmDateStr.substring(0, _firstSlash);
   this.DayStr = prmDateStr.substring(_firstSlash + 1, _secondSlash);
   this.YearStr = prmDateStr.substring(_secondSlash + 1, prmDateStr.length);
   this.MonthNbr = parseInt(this.MonthStr, 10);
   this.DayNbr = parseInt(this.DayStr, 10);
   this.YearNbr = parseInt(this.YearStr, 10);
}

//*******************************************************************************************
//*************************      STRINGS      ***********************************************
//*******************************************************************************************

//********************** Returns whether a string is empty(null) or not *********************
function isEmpty(prmObjOrStr)
{ 
   var _str = typeof(prmObjOrStr)=="object" ? prmObjOrStr.value : prmObjOrStr;  
   
   _str = typeof(_str)=="string" ? _str.replace(/ /g, "") : _str;      
                                                        
   return (_str == "" || _str == null || _str == undefined);
}

//********************************** Trims a string *****************************************
function trimStr(prmStr, prmChar, prmSide)
{   
   var _newStr = prmStr;
   var _char;
   
   if (isEmpty(prmChar)) 
      _char = " ";
   else
      _char = prmChar;

   if (!isEmpty(_newStr) && _newStr != _char)
   {    
      if (prmSide != "right")                                  
         for (var i = 0; i < _newStr.length; i++)
                 {
            if (_newStr.charAt(i) == _char)
                        {
                   _newStr = _newStr.substring(i+1, _newStr.length);
                       i--;
                }
                else
                   break;         
         }      
          if (prmSide != "left")
         for (i = _newStr.length-1; i > 0; i--)
                 {
            if (_newStr.charAt(i) == _char)
                   _newStr = _newStr.substring(0, i);
                else
                   break;
         }         
   }
   else
   if (_newStr == " ")
      _newStr = "";
          
   return _newStr;
}

//**************** CHANGES THE CASE OF A STRING/INPUT BOX ***********************************
function changeCase(InputObj, prmCase)
{       
        if (isEmpty(prmCase) || prmCase=="U")
        InputObj.value = InputObj.value.toUpperCase();
        else
                InputObj.value = InputObj.value.toLowerCase();
}

//**************** DELETES CHARACTER(S) FROM A STRING ***************************************
function delChar(prmStr)
{
        var _newStr = prmStr;
   
        if (!isEmpty(prmStr))   
                for (var i = 0; i < _newStr.length; i++)
                        for (var j = 1; j < arguments.length; j++)
                                if (_newStr.charAt(i) == arguments[j])
                                {
                                        _newStr = _newStr.substring(0, i) + _newStr.substring(i+1, _newStr.length);
                                        i -= 1;
                                }
                                
        return _newStr;   
}

//**************** Inserts any character wanted in a string *********************************
function insertChar(prmStr, prmChar)
{
   var _firstPosition = 0;
   var _newStr = "";

   if (!isEmpty(prmStr))
   {
      for (var i = 2; i < arguments.length; i++)
          {
             _newStr += prmStr.substring(_firstPosition, arguments[i]-1) + prmChar;
                 _firstPosition = arguments[i]-1;
      }
          _newStr += prmStr.substring(_firstPosition, prmStr.length);
   }
   
   return _newStr;  
}

//************ Counts how many times a character appears in a string ************************
function charAppearanceCount(prmStr, prmChar)
{                    
   var _count = 0;
    
   if (!isEmpty(prmStr))
   {     
      for (var i = 0; i < prmStr.length; i++)
         if (prmStr.charAt(i) == prmChar)
            _count++;
   }
   
   return _count;  
}

//*********** Evaluates if a() special character(s) is(are) well positioned *****************      
function areCharPosCorrect(prmStr, prmChar)
{
   if (!isEmpty(prmStr))        
      for (var i = 2; i < arguments.length; i++)
                if (prmStr.charAt(arguments[i]-1) != prmChar)
           return false;
   
   return true;          
}

//*******************************************************************************************
//*************************      NUMBERS      ***********************************************
//*******************************************************************************************

//************* Evaluates if a string(number) contains only digits or not *******************
function isDigitsOnly(prmNbr){                                         
   for (var i = 0; i < prmNbr.length; i++)      
      if (prmNbr.charAt(i)!="0" && prmNbr.charAt(i)!="1" && prmNbr.charAt(i)!="2" && prmNbr.charAt(i)!="3" && prmNbr.charAt(i)!="4" && prmNbr.charAt(i)!="5" && prmNbr.charAt(i)!="6" && prmNbr.charAt(i)!="7" && prmNbr.charAt(i)!="8" && prmNbr.charAt(i)!="9")
          return false;
 
   return true;
}

//********************** Inserts comas in a number ******************************************
function insertComas(prmNbr)
{
   var _newNbr = prmNbr.toString();
   var _dotPos = _newNbr.indexOf(".");
   var _decimal = _dotPos != -1 ? _newNbr.substring(_dotPos, _newNbr.length) : ""; 
   var _lastComaPos;
   
   if (_decimal != "")
      _newNbr = _newNbr.substring(0, _dotPos);
      
   _lastComaPos = _newNbr.length;   
   
   if (_lastComaPos > 3)
   { 
      while (_newNbr.indexOf(",") != 1 && _newNbr.indexOf(",") != 2 && _newNbr.indexOf(",") != 3)
          {
         _newNbr = _newNbr.substring(0, _lastComaPos-3) + "," + _newNbr.substring(_lastComaPos-3, _newNbr.length);
                 _lastComaPos = _lastComaPos - 3;
          }
   } 
   _newNbr += _decimal;
     
   return _newNbr;
}

//******************* Evaluates the comas positions in a number *****************************
function areComaPosCorrect(prmNbr){            
   var i = prmNbr.length;
                                 
   while (i > 3){
      if (prmNbr.charAt(i-4) != ",")
         return false;
      else
         i -= 4;
   }
   return true;
}

//*******************************************************************************************
//*************************       DATES       ***********************************************
//*******************************************************************************************

//********************** Evaluates if a year is leap or not *********************************
function isALeapYear(Year){                                                              
   return (Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0))
}

//******** Continues the date validation (evaluates the details of a date) ******************
function areDateDetailsCorrect(prmDateStr, prmFormat)
{                                             
   var _dateObj = new dateObjConstructor(prmDateStr); 
       
   with (_dateObj)
   {
      if (MonthStr.length == 1)
         MonthStr = "0" + MonthStr;
      if (DayStr.length == 1)
         DayStr = "0" + DayStr;
      if (YearStr.length != 2 && YearStr.length != 4)
         return false;
      else
      if (YearStr.length == 2 && prmFormat != "##/##/##")
          {
         if (YearNbr < 50)
            YearStr = "20" + YearStr;
         else
            YearStr = "19" + YearStr;
      }
          else
      if (YearStr.length == 4 && prmFormat == "##/##/##")
         YearStr = YearStr.substring(2, 4);
                 
      if (MonthNbr > 12 || MonthNbr <= 0 || DayNbr > 31 || DayNbr <= 0)
         return false;
      else
      if (DayNbr >= 31 && (MonthNbr == 4 || MonthNbr == 6 || MonthNbr == 9 || MonthNbr == 11))
         return false;
      else
      if (MonthNbr == 2 && (DayNbr >= 30 || (DayNbr == 29 && !isALeapYear(YearStr))))
         return false;

      date_Saver = MonthStr + "/" + DayStr + "/" + YearStr;
      return true; 
   }
}

//** Continues the date validation (specially validates the characters and length) **********
function isAValidDate(DateObj, prmFormat)
{                                                   
   var _date = trimStr(DateObj.value);
   var _temporaryDate = _date;

   if (areCharPosCorrect(_date, "/", 2, 4) || areCharPosCorrect(_date, "/", 2, 5) || areCharPosCorrect(_date, "/", 3, 5) || areCharPosCorrect(_date, "/", 3, 6) || (charAppearanceCount(_date, "/") == 0 && ((_date.length == 8 && prmFormat != "##/##/##") || _date.length == 6)))
   {
      if (charAppearanceCount(_date, "/") == 0 && ((_date.length == 8 && prmFormat != "##/##/##") || _date.length == 6))
         _date = _date.substring(0, 2) + "/" + _date.substring(2, 4) + "/" + _date.substring(4, _date.length);
                 
      _temporaryDate = _temporaryDate.replace(/\//g, "");
           
      if (isDigitsOnly(_temporaryDate) && _temporaryDate.length > 3 && _temporaryDate.length < 9)
         if (areDateDetailsCorrect(_date, prmFormat))
                 {
            DateObj.value = date_Saver;
            return true;    
         } 
   }
   return false;
}


//** Continues the date validation (specially validates the characters and length) **********
function isAValidDateMonthYear(DateObj)
{                                                   
   var _date = trimStr(DateObj.value);
   var _temporaryDate = _date;

   if ( areCharPosCorrect(_date, "/", 3) && (_date.length >6) )
   {
         if ( (_date.substring(0, 2) > 0) && (_date.substring(0, 2) < 13) && (isDigitsOnly(_date.substring(3, 4))) )
                {
                        return true;
                }
   }
   return false;
}

//******************* EVALUATES A FROM TO DATE RANGE ****************************************
function validFromToDateRange(prmFromDate, prmToDate)
{
        var _fromDate = new dateObjConstructor(prmFromDate);
        var _toDate = new dateObjConstructor(prmToDate);
        var _fromDateDays;     
        var _toDateDays;
   
        if (_fromDate.YearStr.length == 2)
        {
                if (_fromDate.YearNbr < 50)
                        _fromDate.YearNbr = parseInt("20" + _fromDate.YearStr, 10);
                else
                        _fromDate.YearNbr = parseInt("19" + _fromDate.YearStr, 10);
        }         
        if (_toDate.YearStr.length == 2)
        {
                if (_toDate.YearNbr < 50)
                        _toDate.YearNbr = parseInt("20" + _toDate.YearStr, 10);
                else
                        _toDate.YearNbr = parseInt("19" + _toDate.YearStr, 10);
        }
         
        _fromDateDays = _fromDate.YearNbr * 365 + _fromDate.MonthNbr * 30 + _fromDate.DayNbr;
        _toDateDays = _toDate.YearNbr * 365 + _toDate.MonthNbr * 30 + _toDate.DayNbr;
   
        if (_fromDateDays <= _toDateDays)
                return true;
        else 
                return false;             
}

//*******************************************************************************************
//*************************      IMAGES      ************************************************
//*******************************************************************************************

//*** Changes the URL of an image on the onMouseOut, onMouseOver and onClick events *********
function changeToImg(prmImgName, prmImgNbr, prmImgObjName)
{
   if (isEmpty(prmImgObjName))
   {
      if (prmImgName != img_Sel)
         document.images[prmImgName].src = img_Folder + prmImgName + img_End[prmImgNbr-1];
   }
   else
   {
      if (prmImgObjName != img_Sel)
         document.images[prmImgObjName].src = img_Folder + prmImgName + img_End[prmImgNbr-1];       
   }
}

//*******************************************************************************************
//*************************      LAYERS      ************************************************
//*******************************************************************************************

//************** Evaluates whether a Layer is visible or not ********************************
function isLayerVisible(prmLayerName)
{
   if (document.layers)
   {
     if (document.layers[prmLayerName].visibility == "visible")
            return true;
   }
   else
   if (document.all)
   {
     if (document.all(prmLayerName).style.visibility == "visible")
            return true;
   }
   else
   {
     if (document.getElementById(prmLayerName).style.visibility == "visible")
            return true;
   }
   
   return false;
}

//********************** Hides or shows a Layer *********************************************
function hideOrShowLayer(prmObjOrLayerName, prmVisibility, prmPos)
{
   var _layerStyleObj;
   
   if (document.layers)
   {
      if (typeof(prmObjOrLayerName) == "object")
             _layerStyleObj = prmObjOrLayerName;
          else  
             _layerStyleObj = document.layers[prmObjOrLayerName];
   }      
   else
   if (document.all)
   {
      if (typeof(prmObjOrLayerName) == "object")
         _layerStyleObj = prmObjOrLayerName.style;
          else
             _layerStyleObj = document.all(prmObjOrLayerName).style;
   }
   else
   {
      if (typeof(prmObjOrLayerName) == "object")
         _layerStyleObj = prmObjOrLayerName.style;
          else
             _layerStyleObj = document.getElementById(prmObjOrLayerName).style;                      
   }
   
   _layerStyleObj.visibility = prmVisibility;
   _layerStyleObj.position = prmPos;
}

//*******************************************************************************************
//*******************      INPUT VALIDATIONS      *******************************************
//*******************************************************************************************

//********* Puts the focus on the Wrong Input Object ****************************************
function setFocusWrongInput(){
   wrong_InputObj.focus();   
   wrong_InputObj.select();
   
   wrong_InputObj = "";
   clearInterval(interval_ID);
}

//*********** ASSIGNS A DEFAULT VALUE TO AN INPUT OBJECT ************************************      
function fillValWithDefault(prmFormNbr, prmNormal)
{
        with (document.forms[prmFormNbr])
                for (var i = 2; i < arguments.length; i++)
                {
                        if (typeof(arguments[i]) == "object")
                        {
                                if (prmNormal)
                                {
                                        if (isEmpty(trimStr(arguments[i].value)))
                                                arguments[i].value = arguments[i+1];
                                }
                                else
                                {
                                        if (trimStr(arguments[i].value) == arguments[i+1])
                                                arguments[i].value = "";
                                }
                        }
                        else
                        { 
                                if (prmNormal)
                                {   
                                        if (isEmpty(trimStr(elements[arguments[i]].value)))
                                                elements[arguments[i]].value = arguments[i+1];
                                }
                                else
                                {
                                        if (trimStr(elements[arguments[i]].value) == arguments[i+1])
                                                arguments[i].value = "";
                                }
                        }
                        i++;     
                }
}

//**************** Evaluates whether a key(s) was(were) pressed or not **********************
function wasKeyPressed(EventObj)
{
   var _key;
   
   for (var i = 1; i < arguments.length; i++)
   {    
      _key = EventObj != null ? EventObj.keyCode : EventObj.which;
            
      if (arguments[i] == _key)
         return true;
   }
   return false;
}

//********* Fills the value of an Input Object or a string with a wanted character **********      
function fillValWithChar(InputObjOrStr, prmChar, prmWantedLen, prmFillingSide)
{
   var _newVal;
   
   if (typeof(InputObjOrStr) == "object")
      _newVal = trimStr(InputObjOrStr.value);
   else
      _newVal = trimStr(InputObjOrStr);   
   
   if (_newVal != "")
   {
      while (_newVal.length < prmWantedLen)
          {
         if (prmFillingSide == "left")
                _newVal = prmChar + _newVal;
             else
                _newVal = _newVal + prmChar;
      }  
   }
   if (typeof(InputObjOrStr) == "object")
      InputObjOrStr.value = _newVal;
   else
      return _newVal;      
}

//*** Changes the style of a button for the onMouseOut, onMouseOver and onClick events ******
function changeClass(HTMLObjorStr, prmClassNbr)
{
   var _htmlObj;
   
   if (typeof(HTMLObjorStr) == "object")
      _htmlObj = HTMLObjorStr;   
   else
   {
      if (document.layers)
         _htmlObj = document.layers[HTMLObjorStr];         
      else
      if (document.all)
         _htmlObj = document.all(HTMLObjorStr);
      else
         _htmlObj = document.getElementById(HTMLObjorStr);                           
   }
   
   _htmlObj.className = classes[prmClassNbr-1];
}

//*************************** COLORS A ROW **************************************************
function highLOrNotPlainRow(ListObj, prmClassNbr)
{
        if (nav_IE){
                while (ListObj.tagName != "TR")
                        ListObj = ListObj.parentElement;
        }
        else
                while (ListObj.tagName != "TR")
                        ListObj = ListObj.parentNode;

        changeClass(ListObj, prmClassNbr);
}

//*************************** HIGHLIGHTS OR NOT A ROW ***************************************
function hLightOrNotRow(ListObj, prmFormNbr, prmMainCheckBoxName)
{
        if (!isEmpty(ListObj))
        {   
                if (ListObj.type == "radio")
                {   
                        ListObj.checked = true;
                        
                        if (prior_ListObj != ListObj && !isEmpty(prior_ListObj))          
                                highLOrNotPlainRow(prior_ListObj, 3);
                 
                        prior_ListObj = ListObj;
                        highLOrNotPlainRow(ListObj, 4);           
                }
                else
                {
                        // main checkbox control
                        if (!isEmpty(prmMainCheckBoxName))
                        {
                                if (areAllChecked(prmFormNbr, ListObj.name))
                                        document.forms[prmFormNbr].elements[prmMainCheckBoxName].checked = true;
                                else
                                        document.forms[prmFormNbr].elements[prmMainCheckBoxName].checked = false;
                        }
                
                        if (ListObj.checked)
                                highLOrNotPlainRow(ListObj, 4);
                        else
                                highLOrNotPlainRow(ListObj, 3);
                }
        }
}

//*************************** HIGHLIGHTS OR NOT ALL ROWS ************************************
function hLightOrNotAllRows(prmFormNbr, prmGroupName)
{
   with (document.forms[prmFormNbr])
   {
      if (elements[prmGroupName])
          {      
         if (elements[prmGroupName].length != undefined)
                 {
                for (var i = 0; i < elements[prmGroupName].length; i++)
               hLightOrNotRow(elements[prmGroupName][i]);
             }
                 else
                    hLightOrNotRow(elements[prmGroupName]);
          }
   }
}

//****** Checks if there is a radio button or a checkbox checked in a list ******************
function isARadioBtnOrCheckBoxSel(prmFormNbr, prmGroupName, prmAlert)
{
   if (document.forms[prmFormNbr].elements[prmGroupName])
   {
      with(document.forms[prmFormNbr])
          {
         if (elements[prmGroupName].length == undefined)
                 {
                if (elements[prmGroupName].checked)
                       return true;
             }
             else
            for (var i = 0; i < elements[prmGroupName].length; i++)
               if (elements[prmGroupName][i].checked)
                      return true;                                       
      
             if (!isEmpty(prmAlert))
                alert(prmAlert);
             return false;
          }
   }
   else
      return false;
}

//****** EVALUATES WHETHER ALL THE CHECKBOXES ON A GROUP ARE CHECKED *******************
function areAllChecked(prmFormNbr, prmGroupName)
{
   with (document.forms[prmFormNbr])
   {
      if (elements[prmGroupName])
          {      
         if (elements[prmGroupName].length != undefined)
                 {
                    for (var i = 0; i < elements[prmGroupName].length; i++)
                           if (!elements[prmGroupName][i].checked)
                              return false;
                 }
                 else
                 if (!elements[prmGroupName].checked)
                        return false;  
          }
          return true;  
   }     
}

//****** CHECKS OR NOT ALL THE ELEMENTS OF A GROUP (RADIO/CHECKBOX)*********************
function checkOrNotAGroup(prmFormNbr, prmGroupName, prmState)
{
   with(document.forms[prmFormNbr])
   {
      if (elements[prmGroupName])
          {      
         if (elements[prmGroupName].length != undefined)
                 {
                if (elements[prmGroupName][0].type == "radio")
                        {
                       if (prmState)
                              elements[prmGroupName][0].checked = prmState;
                           else
                              for (var i = 0; i < elements[prmGroupName].length; i++)
                     elements[prmGroupName][i].checked = prmState;     
                    }
                    else
               for (var i = 0; i < elements[prmGroupName].length; i++)
                  elements[prmGroupName][i].checked = prmState;
             }
                 else
                    elements[prmGroupName].checked = prmState; 
          }
   }
}

// RETURNS A LIST OBJECT
function getListObj(prmFormNbr, prmGroupName, prmRowNbr)
{
        with (document.forms[prmFormNbr])
        {
                if (elements[prmGroupName])
                {      
                        if (elements[prmGroupName].length == undefined)
                                return elements[prmGroupName]; 
                        else
                                return elements[prmGroupName][prmRowNbr];
                }
                else
                        return "";
        }
}

//* RETURNS THE SELECTED RADIO BUTTON NUMBER OR THE SELECTED CHECKBOXES NUMBERS ON A LIST ***
function getNbrOrValFromList(prmFormNbr, prmGroupName, prmVal)
{
        var _checkBoxesChecked = new Array();
        var j = 0;
          
        with (document.forms[prmFormNbr])
                for (var i = 0; i < length; i++)
                        if (elements[i].name == prmGroupName)
                        {
                                if (elements[i].type == "radio")
                                {
                                        if (elements[i].checked)
                                        {
                                                if (isEmpty(prmVal))            
                                                        return i;
                                                else
                                                        return elements[i].value;
                                        }
                                }
                                else
                                if (elements[i].checked)
                                {
                                        if (isEmpty(prmVal))
                                                _checkBoxesChecked[j] = i;
                                        else
                                                _checkBoxesChecked[j] = elements[i].value;
                                  
                                        j++;                    
                                }         
                        }
                 
        return _checkBoxesChecked;
}

//****** CHECKS OR NOT ALL THE ELEMENTS OF A CHECKBOX GROUP DEPENDING OF A PRINCIPAL CHECKBOX'S STATUS 
function checkOrNotAllList(MainCheckBoxObj, prmFormNbr, prmGroupName, prmHighLightOrNot)
{
   if (MainCheckBoxObj.checked)
      checkOrNotAGroup(prmFormNbr, prmGroupName, 1);      
   else
      checkOrNotAGroup(prmFormNbr, prmGroupName, 0);
        
   if (prmHighLightOrNot)           
      hLightOrNotAllRows(prmFormNbr, prmGroupName);
}

//************* Searches from an input box a value or description in a select box ***********
function searchValOrDesc(prmFormNbr, InputObjOrVal, prmSelectBoxName, prmValOrDesc)
{
        var SelectBoxObj = document.forms[prmFormNbr].elements[prmSelectBoxName]; 
        var _valToCompare = typeof(InputObjOrVal)=="object" ? InputObjOrVal.value : InputObjOrVal;
        var _valOrDesc;   
   
        if (!isEmpty(_valToCompare))
        {
                for (var i=0; i<SelectBoxObj.options.length; i++)
                {
                        _valOrDesc = prmValOrDesc=="value" ? SelectBoxObj.options[i].value : SelectBoxObj.options[i].text;
                        if (_valOrDesc.substring(0,_valToCompare.length).toUpperCase() == _valToCompare.toUpperCase())
                        {
                                SelectBoxObj.selectedIndex = i;
                                break;   
                        } 
                        else
                                SelectBoxObj.selectedIndex = 0;  
                } 
        }
}

//************************* VALIDATES A NUMBER **********************************************
function validateNbr(NbrObj, prmDollarChar, prmDecimalPlaces, prmComas, prmPercentChar)
{
   var _nbr = trimStr(NbrObj.value);
   var _decimal = "";
   var _negativeNbr = false;
          
   if (isEmpty(_nbr))
      return true;
   else
   {  
      // getting rid of non-numeric formating characters
          _nbr = _nbr.replace(/\$/g, ""); 
          _nbr = _nbr.replace(/,/g, "");
          _nbr = _nbr.replace(/%/g, "");
          
          // if it is a negative number
          if (_nbr.indexOf("-") != -1 || _nbr.indexOf("(") != -1)
          {
         _nbr = _nbr.replace(/-/g, "");
             _nbr = _nbr.replace(/\(/g, "");
                 _nbr = _nbr.replace(/\)/g, "");
                 
                 _negativeNbr = true;
          }
          
          // deleting the zeros to the left of the number
          _nbr = trimStr(_nbr, "0", "left");
          if (_nbr=="" || _nbr.charAt(0)==".")
                _nbr = "0" + _nbr;
                
          // if the number is expected to contain decimals 
          if (!isEmpty(prmDecimalPlaces))
          {
             // if the number already contains a decimal value
             if (_nbr.indexOf(".") != -1)
                 {                      
                _decimal = _nbr.substring(_nbr.indexOf(".") + 1, _nbr.length);
                        
                        // the decimal part is trimmed if it contains more places than it was expected to.   
                        if (_decimal.length > prmDecimalPlaces)
                           _decimal = _decimal.substring(0, prmDecimalPlaces);
                        
                        // if the decimal part itself is not a valid number       
                        if (!isDigitsOnly(_decimal))
                        {
                           wrong_InputObj = NbrObj;                       
                           alert("Please enter a valid number on this field.");
                           
                           interval_ID = setInterval("setFocusWrongInput()", 10);
               return false;
                        }
                           
                        _nbr = _nbr.substring(0, _nbr.indexOf("."));
                 }
                 
                 if (_decimal == "")
                    _decimal = "0";
                        
                 // filling the decimal part with the missing places  
                 _decimal = "." + fillValWithChar(_decimal, "0", prmDecimalPlaces, "right");           
          } 
                
          // if the integer part of the number is a valid number 
          if (isDigitsOnly(_nbr))
          {             
             _nbr += _decimal;
                 
             // if the number is going to contain comas 
             if (prmComas)
                _nbr = insertComas(_nbr);
                        
                 // if the number is going to contain the dollar character
                 if (prmDollarChar)     
                    _nbr = "$" + _nbr;
                        
             // if the number is a negative number
                 if (_negativeNbr)      
                    _nbr = "(" + _nbr + ")";
                
                 // if the number is going to contain the percent character
                 if (prmPercentChar)    
                    _nbr += "%";
                                
                 NbrObj.value = _nbr;
                 return true;  
          }   
          else
          {
         wrong_InputObj = NbrObj;                         
             alert("Please enter a valid number on this field.");
                           
             interval_ID = setInterval("setFocusWrongInput()", 10);
         return false;
      }          
   }   
}

//*************** EVALUATES WHETHER AN AMOUNT IS ZERO OR NOT ********************************
function isAmountZero(AmountObj, prmAlert)
{
        var _amount = 0;
        
        if (!isEmpty(AmountObj))
        {
                _amount = parseFloat(AmountObj.value.replace(/\$/g, ""));
        }               
                
        if (_amount == 0)
        {
                if (!isEmpty(prmAlert))
                        alertAndFocus(AmountObj, prmAlert);
                        
                return true;
        }
        else
                return false;
}

//************************* Validates a Zip Code ********************************************
function validateZipCode(ZipCodeObj, prmZipCodeLen)
{
   var _zipCodeNbr = trimStr(ZipCodeObj.value);
  
   if (isEmpty(_zipCodeNbr))
      return true;
   else
   if (_zipCodeNbr.length == prmZipCodeLen && isDigitsOnly(_zipCodeNbr))
      return true;
   else
   {
      wrong_InputObj = ZipCodeObj;                                                               
      alert("Invalid Zip Code. Please enter " + prmZipCodeLen + " digits.");
          
          interval_ID = setInterval("setFocusWrongInput()", 10);
      return false;
   }   
   return true;
}

//*************** Validates a Social Security Number ****************************************
function validateSSN(SSNObj)
{
        var _ssn = trimStr(SSNObj.value);
        var _tSaver = "";
  
        if (isEmpty(_ssn))
                return true;
        else
        if ((_ssn.length == 9 && charAppearanceCount(_ssn, '-') == 0) || (_ssn.length == 11 && charAppearanceCount(_ssn, '-') == 2))
        {
                if (_ssn.charAt(0).toUpperCase() == "T")
                {
                        _tSaver = "T";
                        _ssn = _ssn.substring(1, _ssn.length);
                }       
                _ssn = delChar(_ssn, '-');
                if (isDigitsOnly(_ssn))
                {
                        _ssn = _tSaver + _ssn;
                        _ssn = insertChar(_ssn, '-', 4, 6);
                        SSNObj.value = _ssn;
                        return true;             
                }                 
        }  
        
        wrong_InputObj = SSNObj;
        alert("Invalid Social Security Number. Please use ######### or ###-##-#### format.");
        interval_ID = setInterval("setFocusWrongInput()", 10); 
        return false;
}

//************************* Validates a Phone Number ****************************************
function validatePhoneNbr(PhoneNbrObj, prmAlert)
{
   var _phoneNbr = trimStr(PhoneNbrObj.value);
  
   if (isEmpty(_phoneNbr))
      return true;
   else
   {
      _phoneNbr = _phoneNbr.replace(/\(/g, "");
          _phoneNbr = _phoneNbr.replace(/\)/g, "");     
          _phoneNbr = _phoneNbr.replace(/-/g, "");

          if (isDigitsOnly(_phoneNbr) && _phoneNbr.length == 10)
          {
             _phoneNbr = insertChar(_phoneNbr, '-', 4, 7);
                 PhoneNbrObj.value = _phoneNbr;
                 return true;               
          }  
          else
          {              
             wrong_InputObj = PhoneNbrObj;
                                                 
             if (isEmpty(prmAlert))               
            alert("Invalid Phone Number. Please use ###-###-#### or ########## format.");
             else
             if (prmAlert == 1)
                alert("Invalid Fax Number. Please use ###-###-#### or ########## format.");
                 
             interval_ID = setInterval("setFocusWrongInput()", 10); 
         return false;
          }      
   }
   return true;
}

//************************* Validates a Year ************************************************
function validateYear(YearObj)
{
   var _year = trimStr(YearObj.value);
  
   if (isEmpty(_year))
      return true;
   else
   if (_year.charAt(0) == "0" || _year.length != 4 || !isDigitsOnly(_year))
   {
      wrong_InputObj = YearObj;                   
      alert("Invalid Year. Please use #### format.");
          
          interval_ID = setInterval("setFocusWrongInput()", 10);
      return false;      
   }
   return true;
}

//************************* Validates a Number Range ****************************************
function validateNbrRange(NbrObj, prmDollarChar, prmDecimalPlaces, prmComas, prmStart, prmEnd, prmAlert)
{
   var _nbr = trimStr(NbrObj.value);
          
   if (isEmpty(_nbr))
      return true;
   else   
   if (validateNbr(NbrObj, prmDollarChar, prmDecimalPlaces, prmComas))
   {
          _nbr = _nbr.replace(/\$/g, ""); 
          _nbr = parseFloat(_nbr.replace(/,/g, ""));
                 
      if (parseFloat(prmStart) > _nbr || _nbr > parseFloat(prmEnd))
          {
             wrong_InputObj = NbrObj;   
                 
                 if (isEmpty(prmAlert))           
                alert("Invalid Entry. The allowed range is from " + prmStart + " to " + prmEnd + ".");
                 else
                    alert(prmAlert);
                 
                 interval_ID = setInterval("setFocusWrongInput()", 10);
         return false;          
          }
          else
             return true;
   }
   else
      return false;
}

//************************ FORMATS A FIELD FOR THE INPUT ENTRY ******************************
function formatForInput(InputObj)
{
   var _val = InputObj.value;
   
   // getting rid of formating characters
   _val = _val.replace(/\$/g, ""); // used in numbers
   _val = _val.replace(/,/g, "");  // used in numbers
   _val = _val.replace(/%/g, "");  // used in percent numbers
   _val = _val.replace(/-/g, "");  // used in phone numbers
          
   // if it is a negative number
   if (_val.indexOf("(") != -1)
   {
          _val = _val.replace(/\(/g, "");
          _val = _val.replace(/\)/g, "");
          _val = "-" + _val;
   }
          
   InputObj.value = _val;
   InputObj.select();
}

//*********** SUMS, SUBSTRACTS, MULTIPLIES or DIVIDES NUMERIC VALUES ************************
function validateMathOpNbr(prmFormNbr, TotalObjName, CurrentInputObj, NbrObjs, prmMathOp, prmDollarChar, prmDecimalPlaces, prmComas, prmDollarCharTotal, prmDecimalPlacesTotal, prmComasTotal)
{   
   var _dollarChar = isEmpty(prmDollarCharTotal) ? prmDollarChar : prmDollarCharTotal;
   var _decimalPlaces = isEmpty(prmDecimalPlacesTotal) ? prmDecimalPlaces : prmDecimalPlacesTotal;
   var _comas = isEmpty(prmComasTotal) ? prmComas : prmComasTotal;
   var _decimal = "";
   var _nbr;
   var _sum = 0;    
   var _mathOp = prmMathOp;  
   
   with (document.forms[prmFormNbr])   
   {
      // calculate only when a numeric entry is valid(Input Box) or when there is no need to check a numeric entry 
      if (typeof(CurrentInputObj)!="object" || (typeof(CurrentInputObj)=="object" && validateNbr(CurrentInputObj, prmDollarChar, prmDecimalPlaces, prmComas)))
      {                      
         for (var i = 0; i < NbrObjs.length; i++)
             {  
                    // if one of the number array elements is a math operation, then the math operation is changed and it jumps to the next element 
                    if (NbrObjs[i] == "+" || NbrObjs[i] == "-" || NbrObjs[i] == "*" || NbrObjs[i] == "/")
                        {
                           _mathOp = NbrObjs[i];
                           continue; 
                        }

                    // getting the form element value or a plain number value            
                    _nbr = typeof(NbrObjs[i]) == "string" ? elements[NbrObjs[i]].value : NbrObjs[i];

                        // initialize if no value
                    if (isEmpty(_nbr))
                   _nbr = 0;
                else
                        // getting rid of non-numeric formating characters if the value is a string
                        if (typeof(_nbr) == "string")
                        {
               _nbr = _nbr.replace(/\$/g, "");
                           _nbr = _nbr.replace(/,/g, "");
                           
                           // if it is a negative number
                           if (_nbr.indexOf("-") != -1 || _nbr.indexOf("(") != -1)
                           {
                              _nbr = _nbr.replace(/-/g, "");
                              _nbr = _nbr.replace(/\(/g, "");
                                  _nbr = _nbr.replace(/\)/g, "");
                                  _nbr = "-" + _nbr;
                           }
                           
                           _nbr = parseFloat(_nbr);
            }
                        
                        // addition
                        if (_mathOp == "+")
                           _sum += _nbr;
                        else
                        // substraction
                        if (_mathOp == "-")
                        {
                           if (i == 0)
                              _sum = _nbr;
                           else
                                  _sum -= _nbr;
                        }                       
                        else
                        // multiplication
                        if (_mathOp == "*")
                        {
                           if (i == 0)
                              _sum = _nbr;
                           else
                                  _sum *= _nbr;
                        }
                        else
                        // division
                        if (_mathOp == "/")
                        {                          
                           if (i == 0)
                              _sum = _nbr;
                           else
                                  _sum /= _nbr;
                        }
         }

                 // if the total didn't result a finite number
                 if (_sum == Infinity || _sum == -Infinity)
                    _sum = "";
                        
                 // formating and assigning a numeric value to the Total Object
             elements[TotalObjName].value = _sum;                                                
                 validateNbr(elements[TotalObjName], _dollarChar, _decimalPlaces, prmComas);                                    
         return true;
      }
          else
          {
         elements[TotalObjName].value = "";
                 return false;
          }   
   }   
}

function validateNumberGreaterThan(NbrObj, NbrObjPrevious)
{
        var _nbrThis = trimStr(NbrObj.value);
        var _nbrPrevious = trimStr(NbrObjPrevious.value);
        
        
        wrong_InputObj = NbrObj;
        
        
        if (_nbrThis == "" || _nbrPrevious == "")
                return true;
        
        if (parseFloat(_nbrPrevious) < parseFloat(_nbrThis))
        {
                return true;
        }
        else
        {
                alert("Please enter a number greater than the one on the previous cell.");
                 interval_ID = setInterval("setFocusWrongInput()", 10);
         return false; 
        }
}

function validateNumberSmallerThan(NbrObj, NbrObjNext)
{
        var _nbrThis = trimStr(NbrObj.value);
        var _nbrNext = trimStr(NbrObjNext.value);
        
        
        wrong_InputObj = NbrObj;
        
        
        if (_nbrThis == "" || _nbrNext == "")
                return true;
        
        if (parseFloat(_nbrThis) < parseFloat(_nbrNext))
        {
                return true;
        }
        else
        {
                alert("Please enter a number greater than the one on the previous cell.");
                 interval_ID = setInterval("setFocusWrongInput()", 10);
         return false; 
        }
}



//************************* Validates a Date ************************************************
function validateDate(DateObj, prmFormat)
{   
   if (!isEmpty(trimStr(DateObj.value)))   
      if (!isAValidDate(DateObj, prmFormat))
          {
             wrong_InputObj = DateObj;
                             
             if (prmFormat == "##/##/##")                    
                    alert("Invalid Date. Please use M/D/YY, MM/DD/YY or MMDDYY format."); 
                 else 
            alert("Invalid Date. Please use M/D/YY, MM/DD/YYYY, MMDDYY or MMDDYYYY format.");
                
                 interval_ID = setInterval("setFocusWrongInput()", 10);
         return false; 
      }      
   return true;
}


//************************* Validates a Date ************************************************
function validateDateMonthYear(DateObj)
{   
   if (!isEmpty(trimStr(DateObj.value)))   
      if (!isAValidDateMonthYear(DateObj))
          {
             wrong_InputObj = DateObj;                       
                 alert("Invalid Date. Please use MM/YYYY format.");             
                 interval_ID = setInterval("setFocusWrongInput()", 10);
         return false; 
      }      
   return true;
}

//************************ VALIDATES IF FROM DATE <= TODATE *****************************
function validateDatesRange(FromDateObj, ToDateObj, prmAlert)
{
        var _fromDate;
        var _toDate;      
        var _todayDate = new Date();
        var _alert = isEmpty(prmAlert) ? "Invalid Period. 'From' Date should be <= than 'To' Date." : prmAlert;
   
        if (FromDateObj == "")
        {
                _todayDate = _todayDate.getMonth()+ 1 + "/" + _todayDate.getDate() + "/" + _todayDate.getFullYear();      
                _fromDate = _todayDate;
        }
        else
        if (!isEmpty(trimStr(FromDateObj.value)))
                _fromDate = FromDateObj.value;
        else
                return true;     
 
        if (!isEmpty(trimStr(ToDateObj.value)))
        {
                _toDate = ToDateObj.value;
                          
                if (!validFromToDateRange(_fromDate, _toDate))
                {
                        alertAndFocus(ToDateObj, _alert);
                        return false;
                }
        }
        return true;
}

//**************** CALCULATES THE DIFFERENCE IN YEARS BETWEEN TWO DATES *****************
function getDatesDifference(FirstDateObj, SecondDateObj, DifferenceObj)
{  
        var _firstDate;
        var _secondDate;
        var _difference;
        var _todayDate = new Date();
   
        // compare with another date
        if (typeof(SecondDateObj) == "object")
        {
                if (!isEmpty(SecondDateObj))
                        _secondDate = new dateObjConstructor(SecondDateObj.value);
                else
                        return 0;
        }
        else
        // compare with today's date
        {
                _todayDate = _todayDate.getMonth()+ 1 + "/" + _todayDate.getDate() + "/" + _todayDate.getFullYear();      
                _secondDate = new dateObjConstructor(_todayDate);
        }
                                            
        if (!isEmpty(trimStr(FirstDateObj.value)))
        {
                _firstDate = new dateObjConstructor(FirstDateObj.value);
        
                if (_firstDate.YearStr.length == 2)
                {
                        if (_firstDate.YearNbr < 50)
                                _firstDate.YearNbr = parseInt("20" + _firstDate.YearStr, 10);
                        else
                                _firstDate.YearNbr = parseInt("19" + _firstDate.YearStr, 10);
                }         
                if (_secondDate.YearStr.length == 2)
                {
                        if (_secondDate.YearNbr < 50)
                                _secondDate.YearNbr = parseInt("20" + _secondDate.YearStr, 10);
                        else
                                _secondDate.YearNbr = parseInt("19" + _secondDate.YearStr, 10);
                }

                if (_firstDate.MonthNbr > _secondDate.MonthNbr)
                        _difference = _secondDate.YearNbr - _firstDate.YearNbr - 1;
                else
                if (_firstDate.MonthNbr == _secondDate.MonthNbr && _firstDate.DayNbr > _secondDate.DayNbr)
                        _difference = _secondDate.YearNbr - _firstDate.YearNbr - 1;
                else 
                        _difference = _secondDate.YearNbr - _firstDate.YearNbr;
          
                if (_difference < 0)
                        _difference = 0;
                
                if (typeof(DifferenceObj) == "object")
                        DifferenceObj.value = _difference;
                else
                        return _difference;
        }
   
        return 0;
}

//****** GETS THE FILE NAME AND/OR PATH FROM A FILE OBJECT **********************************
function getFileNameAndPath(prmFormNbr, FileObj, prmFileNameObjOrStr, prmPathObjOrStr)
{
   var _lastSlash = FileObj.value.lastIndexOf('\\');   
   var _fileNameObj;
   var _pathObj;
   
   if (prmFileNameObjOrStr != null && prmFileNameObjOrStr != "") 
   {
      _fileNameObj = typeof(prmFileNameObjOrStr)=="object" ? prmFileNameObjOrStr : document.forms[prmFormNbr].elements[prmFileNameObjOrStr];
      _fileNameObj.value = FileObj.value.substring(_lastSlash+1, FileObj.value.length);
   }
   
   if (prmPathObjOrStr != null && prmPathObjOrStr != "")
   {
      _pathObj = typeof(prmPathObjOrStr)=="object" ? prmPathObjOrStr : document.forms[prmFormNbr].elements[prmPathObjOrStr];
          _pathObj.value = FileObj.value.substring(0, _lastSlash+1);
   }      
}

//*******************************************************************************************
//*************************      FORMS      *************************************************
//*******************************************************************************************

//****** Displays an alert message and put the focus on the wanted form element *************
function alertAndFocus(FocusObj, prmAlert)
{
   alert(prmAlert); 
          
   if (FocusObj.type != "select-one" && FocusObj.type != "select-multiple")
      FocusObj.select();
                    
   FocusObj.focus();
}

//********** Enables or Disables all the elements of a Form *********************************
function enableOrDisableForm(prmFormNbr, prmState)
{
   with (document.forms[prmFormNbr])
      for (var i = 0; i < length; i++)
             for (var j = 2; j < arguments.length; j++)
                 {
                    if (arguments[j] == elements[i].name)
                           break;
                        else
                        if (j == arguments.length-1) 
               elements[i].disabled = prmState;
                 }
}

//*** EVALUATES WHETHER THE PAGE IS READY TO BE SUBMITTED OR NOT (required fields alert) ****
function isReadyToSubmit(prmFormNbr, FldsInfoObj, prmAlertSection)
{  
        var _fldName;
        var _htmlObj;
        var _firstMissingFldObj = "";
        var _missingFlds = false;
        var _missingFldNbr = 0;
        var _newMissingFld;
        var _noZeros = false;
        var _alertSection = isEmpty(prmAlertSection) ? ":\n" : " on the\n" + prmAlertSection + " Section:\n\n";
        var _alert = "Please enter the following required field(s)" + _alertSection;   
         
        for (var i = 0; i < FldsInfoObj.length; i++)
        {      
                _fldName = FldsInfoObj[i][0];
          
                // some numeric fields can't be zero
                if (_fldName.indexOf("#####") != -1)
                {
                        _fldName = _fldName.replace(/#####/g, "");
                        _noZeros = true;
                }
                          
                if (document.forms[prmFormNbr].elements[_fldName])
                { 
                        _htmlObj = document.forms[prmFormNbr].elements[_fldName];
                        if (_htmlObj.length != undefined && _htmlObj.type == undefined)
                                _htmlObj = _htmlObj[0];
                        
                        if (!_htmlObj.disabled)
                        {
                                _newMissingFld = false;
                        
                                if (_htmlObj.type != "radio" && _htmlObj.type != "checkbox")
                                {
                                        if (isEmpty(_htmlObj) || (_noZeros && isAmountZero(_htmlObj)))
                                                _newMissingFld = true;                        
                                }
                                else
                                        if (!isARadioBtnOrCheckBoxSel(prmFormNbr, _fldName))
                                _newMissingFld = true;
                                                
                                if (_newMissingFld)
                                {
                                        _missingFlds = true;
                                        _missingFldNbr++;
                                        _alert += "     " + _missingFldNbr + "- " + FldsInfoObj[i][1] + ".\n";
                           
                                        if (_firstMissingFldObj == "")
                                                _firstMissingFldObj = _htmlObj;
                                }
                        }       
                } 
          
                _noZeros = false;
        }
   
        if (_missingFlds)
        {
                alertAndFocus(_firstMissingFldObj, _alert);
                return false;
        }
        else
                return true;
}

// Changes the Action property of a form and Submits it, passing special values to hidden fields
function changeActionAndSubmit(prmFormNbrorObj, prmAction)
{
   var _formObj = typeof(prmFormNbrorObj) == "object" ? prmFormNbrorObj : document.forms[prmFormNbrorObj]; 
   
   with (_formObj)
   {
      action = prmAction; 
             
      if (arguments.length > 2)
         for (var i = 2; i < arguments.length; i++)
                 {
            elements[arguments[i]].value = arguments[i+1];                          
            i++;
         }
     
      submit();
   }
}

//*******************************************************************************************
//*************************    WINDOWS    ***************************************************
//*******************************************************************************************

//********************* Opens up a PopUp Window *********************************************
function openPopUpWindow(WindowObj, prmWindowPath, prmWidth, prmHeight, prmStatus, prmResizable, prmScrollBars, prmLeftPos, prmTopPos, prmMenuBar, prmToolBar)
{
        var _leftPos;
        var _topPos;
        var _screenW;
        var _screenH;
        
        if (typeof(WindowObj) == "object")
        {
                if (!WindowObj.closed)   
                        WindowObj.close();
                 
                WindowObj = "";
        }       
        
        // getting the x and y coordinates
        if (document.layers) 
        {
                _leftPos = "screenX=";
                _topPos = "screenY=";
                _screenW = window.screenX;
                _screenH = window.screenY;
        }
        else 
        {
                _leftPos = "left=";
                _topPos = "top=";
                _screenW = screen.width;
                _screenH = screen.height;
        }

        // center the window             
        if (isEmpty(prmLeftPos) && !isEmpty(prmWidth))
        {
                _leftPos += ((_screenW-prmWidth)/2);
                _topPos += ((_screenH-prmHeight)/2);
        }
        else
        // exact X & Y coordinates
        if (typeof(prmLeftPos) == "number")
        {
                _leftPos += prmLeftPos;
                _topPos += prmTopPos;
        }        
         
        WindowObj = window.open(prmWindowPath,"","width=" + prmWidth + ",height=" + prmHeight + ",status=" + prmStatus + ", resizable=" + prmResizable + ",scrollbars=" + prmScrollBars + "," + _leftPos + "," + _topPos + ",menubar=" + prmMenuBar + ",toolbar=" + prmToolBar);
        
        return WindowObj;             
}


//********************* CLOSES ALL THE WINDOW'S CHILDREN ************************************
function closeWindowChildren()
{
        for (var i = 0; i < arguments.length; i++)
                if (typeof(arguments[i]) == "object")
                        if (!arguments[i].closed) 
                        {
                                arguments[i].close();            
                                arguments[i] = "";
                        }
}

//********************* Resizes and places a PopUp Window in the center of the screen *******
function resizeAndPlaceWindow(prmWidth, prmHeight){
   window.resizeTo(prmWidth, prmHeight);
   window.moveTo((screen.width-prmWidth)/2, (screen.height-prmHeight)/2);
}
