/*
//эти уже проверил
function IsOneInteger(theElem)
function IsInteger(theElem, sFormName)
function IsOneFloat(theElem)
function IsFloat(vElement, sMsg, sFormName)
function IsOneEmpty(theElem, bShowMsg)
function IsEmpty(vElement, sMessage, sFormName)
function IsFloatPozitiveStrict(vElement, sMsg, sFormName)
function IsFloatPozitive(vElement, sMsg, sFormName)
function ShowMessage_ForFloat(sMsg);

//эти пока нет
function IsOneRangeInteger(theElem, minValue, maxValue)
function IsRangeInteger(theElem, minValue, maxValue, sFormName)
function IsOneRangeFloat(theElem, minValue, maxValue)
function IsRangeFloat(theElem, minValue, maxValue, sFormName)
function IsEmail(theElem)
function IsDate(theElem, DF, sSeparators)
function IsTime(theElem)
function IsIntPriv(theInt)
function IsFloatPriv(theFloat)
*/

// public functions ================================================

var sVLD_NOMESS = "no";
var bVLD_STRICT = true;
var bVLD_NOSTRICT = false;

var sVLD_POZITIVE_STRICT  = "sVLD_POZITIVE_STRICT";
var sVLD_POZITIVE         = "sVLD_POZITIVE";

//--------------------------------------------------------------

function IsElementExists(sElementName, vForm)
{
  if (typeof(vForm) == "string" )
  {
    oForm = document.forms[vForm];
  }
  else
  {
    oForm = vForm;
  }

  for (i = 0; i < oForm.elements.length; i++)
  {
    if (oForm.elements[i].name == sElementName)
    {
      return true;
    }
  }
  return false;
}

//--------------------------------------------------------------

function ShowMessage(sMsg, sGeneralMsg)
{
  sMsg = s_Init(sMsg, sGeneralMsg);
  if (sMsg == "") {sMsg = sGeneralMsg;}
  if (sMsg != sVLD_NOMESS)
  {
    alert(sMsg);
  }
}

    
/*---------------------------------------------------------*/

function ShowMessage_ForFloat(sMsg)
{
  sMsg = s_Init(sMsg, "");
  if (sMsg != "") 
  {
    bPozitiveStrict = s_GetPrefix (sMsg, sVLD_POZITIVE_STRICT);
    if (bPozitiveStrict) {sMsg = s_CutPrefix(sMsg, sVLD_POZITIVE_STRICT);}
    bPozitive = s_GetPrefix (sMsg, sVLD_POZITIVE);
    if (bPozitive) {sMsg = s_CutPrefix(sMsg, sVLD_POZITIVE);}
  }
  
  if (sMsg == "") 
  {
    if (bPozitiveStrict) {sMsg = g_NeedPOZITIVE_STRICT;}
    else
    {
      if (bPozitive) {sMsg = g_NeedPOZITIVE;}
      else { sMsg = g_NeedDecimalNumber; }
    }
  }

  if (sMsg != sVLD_NOMESS)
  {
    alert(sMsg);
  }
  
}


//-----------------------------------------------------------

function IsOneInteger(theElem, sMsg)
{
  if( theElem.value != "" )
    result = IsIntPriv(theElem.value);
  else
    result = true;

  if( !result )
  {
    ShowMessage(sMsg, g_NeedWholeNumber);
    theElem.focus();
  }
  
  return result;
}


//-------------------------------------------------------------------

function IsInteger(vElement, sMsg, sFormName)
{
  if ( (typeof(vElement) == "string") && ( typeof(sFormName) != "string") )
  {
    alert(s_Replace(g_WrongParams, "#FUNC#", "IsInteger"));
    return false;
  }
  
  var bMulti = ( typeof(vElement) == "string" );
  
  if (!bMulti)
  {
    return IsOneInteger(vElement, sMsg);
  }
  else
  {

    var oForm = document.forms[sFormName];
    var i;
    var oNextElement;
    var iErrorsCount = 0;
    var iFirstElemIndex = -1;
    var iFirstErrorElemIndex = -1;

    for (i = 0; i < oForm.elements.length; i++)
    {
      oNextElement = oForm.elements[i];
      if ( s_Left(oNextElement.name, vElement.length) == vElement )
      {
        if (iFirstElemIndex == -1) {iFirstElemIndex = i;}

        if (!IsOneInteger(oNextElement, sVLD_NOMESS)) 
        {
          if (iFirstErrorElemIndex == -1) {iFirstErrorElemIndex = i;}
          iErrorsCount ++ ;
        }
      }
    }

    if (iFirstElemIndex == -1) 
    {
      return -1;
    }
    else
    {
      if (iErrorsCount != 0)
      {
        ShowMessage(sMsg, g_NeedWholeNumber);
        oForm.elements[ iFirstErrorElemIndex ].focus();
      }
      return iErrorsCount;
    }

  }
}

//-------------------------------------------------------------------

function IsOneFloat(oElem, sMsg)
{

  sMsg = s_Init(sMsg, "");  
  
  sStr = oElem.value;
  if( sStr != "" )
  {
    result = IsFloatPriv(sStr, sMsg);
  }else
    result = true;
  
  if( !result )
  {
    ShowMessage_ForFloat(sMsg, g_NeedDecimalNumber);
    oElem.focus();
  }
  
  return result;
}

/*---------------------------------------------------------*/

function IsFloatPozitiveStrict(vElement, sMsg, sFormName)
{
  sMsg = s_Init(sMsg, "");
  sFormName = s_Init(sFormName, "");
  
  return IsFloat(vElement, sVLD_POZITIVE_STRICT + sMsg, sFormName);
  
}

/*---------------------------------------------------------*/

function IsFloatPozitive(vElement, sMsg, sFormName)
{
  sMsg = s_Init(sMsg, "");
  sFormName = s_Init(sFormName, "");
  return IsFloat(vElement, sVLD_POZITIVE + sMsg, sFormName);
}

//-------------------------------------------------------------------

function IsFloat(vElement, sMsg, sFormName)
{
  
  if ( (typeof(vElement) == "string") && ( typeof(sFormName) != "string") )
  {
    alert(s_Replace(g_WrongParams, "#FUNC#", "IsFloat"));
    return false;
  }

  sMsg = s_Init(sMsg, "");  
  
  var bMulti = ( typeof(vElement) == "string" );

  if (!bMulti)
  {
    return IsOneFloat(vElement, sMsg);
  }
  else
  {

    var oForm = document.forms[sFormName];
    var i;
    var oNextElement;
    var iErrorsCount = 0;
    var iFirstElemIndex = -1;
    var iFirstErrorElemIndex = -1;


    for (i = 0; i < oForm.elements.length; i++)
    {
      oNextElement = oForm.elements[i];
      if ( s_Left(oNextElement.name, vElement.length) == vElement )
      {
        if (iFirstElemIndex == -1) {iFirstElemIndex = i;}

        if (!IsOneFloat(oNextElement, sVLD_NOMESS)) 
        {
          if (iFirstErrorElemIndex == -1) {iFirstErrorElemIndex = i;}
          iErrorsCount ++ ;
        }
      }
    }

    if (iFirstElemIndex == -1) 
    {
      return -1;
    }
    else
    {
      if (iErrorsCount != 0)
      {
        ShowMessage(sMsg, g_NeedDecimalNumber);
        oForm.elements[ iFirstErrorElemIndex ].focus();
      }
      return iErrorsCount;
    }

  }
}

//-------------------------------------------------------------------

function IsOneRangeInteger(theElem, minValue, maxValue)
{
  minValue = s_Init(minValue, "");
  maxValue = s_Init(maxValue, "");
  
  result = true;
  iInt = theElem.value;

  if( iInt != "" )
  {
    if( !IsIntPriv(iInt) )
      result = false;
    else
    {
      tempInt = parseInt(s_RemoveLeadZeros(iInt))
      if (minValue != "") 
      {
        if (tempInt < minValue) {result = false;}
      }
      
      if (result) 
      {
        if (maxValue != "") 
        {
           if (tempInt > maxValue) {result = false;}
        }
      }
    }

    // show error message
    if( !result )
    {
      if (maxValue != "" && minValue != "") 
      {
        var sError = g_NeedRangeWholeNumber;
      }
      else
      {
        if (maxValue != "") 
        {
          var sError = g_NeedWholeNumberNoMoreThan;
        }
        else
        {
          var sError = g_NeedWholeNumberNoLessThan;
        }      
      }      
      
      var sError = s_Replace(sError, "#FROM#", minValue);
      sError = s_Replace(sError, "#TO#", maxValue);
      alert(sError);
      theElem.focus();
    }
  }
  
  return result;
}

//-------------------------------------------------------------------

function IsRangeInteger(theElem, minValue, maxValue, sFormName)
{

  if ( (typeof(theElem) != "object") && ( typeof(sFormName) == "undefined") )
  {
    alert(s_Replace(g_WrongParams, "#FUNC#", "IsRangeInteger"));
    return false;
  }
  
  var bMulti = ( typeof(theElem) == "string" );
  
  if (!bMulti)
  {
    return IsOneRangeInteger(theElem, minValue, maxValue);
  }
  else
  {
    var oForm = document.forms[sFormName];
    var i;
    var oNextItem;

    for (i = 0; i < oForm.elements.length; i++)
    {
      oNextItem = oForm.elements[i];
      if ( s_Left(oNextItem.name, theElem.length ) == theElem )
      {
        if (!IsOneRangeInteger(theElem, minValue, maxValue)) {return false;}
      }
    }
    return true;
  }
}

//-------------------------------------------------------------------

function IsOneRangeFloat(theElem, minValue, maxValue)
{
  result = true;
  aFloat = theElem.value;


  if( aFloat != "" )
  {
//    aFloat = aFloat.replace( theDot, "." );    


    if( !IsFloatPriv(aFloat) )
    {
      result = false;
    }
    else
    {
      tempFloat = parseFloat(aFloat);
      if ( !(( tempFloat >= minValue )&&( tempFloat <= maxValue )))
        result = false;
    }


    // show error message
    if( !result )
    {
      var sError = s_Replace(g_NeedRangeDecimalNumber, "#FROM#", minValue);
      sError = s_Replace(sError, "#TO#", maxValue);
      alert(sError);
      theElem.focus();
		}
	}

	
	return result;
}

//-------------------------------------------------------------------

function IsRangeFloat(theElem, minValue, maxValue, sFormName)
{


  if ( (typeof(theElem) == "string") && ( typeof(sFormName) != "string") )
  {
    alert(s_Replace(g_WrongParams, "#FUNC#", "IsRangeFloat"));
    return false;
  }
  
  var bMulti = ( typeof(theElem) == "string" );

  
  if (!bMulti)
  {
    return IsOneRangeFloat(theElem, minValue, maxValue);
  }
  else
  {
    var oForm = document.forms[sFormName];
    var i;
    var oNextItem;


    for (i = 0; i < oForm.elements.length; i++)
    {
      oNextItem = oForm.elements[i];
      if ( s_Left(oNextItem.name, theElem.length ) == theElem )
      {
        if (!IsOneRangeFloat(theElem, minValue, maxValue)) {return false;}
      }
    }
    return true;
  }
}

//----------------------------------------------------------------

function IsEmail(theElem)
{
  result = true;
  aStr = theElem.value;
  count = aStr.length;
  
  if( count!=0 )
  {
    // get index of @
    inda = aStr.indexOf("@",0)
  
    // check for more @ and first/last @
    if( (aStr.indexOf("@",inda+1)!=-1)||(inda==0)||(inda==count-1))
      result = false;

    // check dot before @
    indd = aStr.indexOf(".",0)
    if(indd==inda-1)
      result = false;
    
    // get index of dot after @
    indd = aStr.indexOf(".",inda+1)
  
    // dot must be available. It can't be near and or @
    if( (indd==-1)||(indd==inda+1)||(indd==count-1))
      result = false;

    // show error message
    if( !result )
    {
      alert(g_NeedEmail);
      theElem.focus();
    }
  }

  return result;
}

//------------------------------------------------------------

function IsOneEmpty(oElement, sMessage)
{
  switch (oElement.type)
  {
  case "checkbox":
  case "radio":
    bEmpty = ! oElement.checked;
    break;
  case "select-one":
    bEmpty = (oElement[oElement.selectedIndex].value == "")
    break;
  default:
    bEmpty = (oElement.value == "")
    break;
  }
  
  if (bEmpty)
  {

    if (sMessage != sVLD_NOMESS)
    {
      sMessage = s_Init(sMessage, g_ReqField);
      if (sMessage == "") {sMessage = g_ReqField;}
      alert( sMessage );
      oElement.focus();
    }
  }
  return bEmpty;
}

//-------------------------------------------------------------

function IsEmpty(vElement, sMessage, sFormName, bGetCountOfEmpties)
{
//alert("vElement=" + vElement);

  if ( (typeof(vElement) == "string") && ( typeof(sFormName) != "string") )
  {
    alert(s_Replace(g_WrongParams, "#FUNC#", "IsEmpty"));
    return true;
  }

  var oForm;
  var bMulti = ( typeof(vElement) == "string" );


  if (bMulti) 
  {
    oForm = document.forms[sFormName];
    oElement = oForm.elements[vElement];

//alert("vElement=" + vElement + "\n" + "oElement.length= " + oElement.length);
//alert("vElement=" + vElement + "\n" + "oElement.type= " + typeof(oElement));
    
    if (typeof(oElement) == "object")
    {
      if (!(oElement.length > 0)) 
      {
        vElement = oForm.elements[vElement];
        bMulti = false;
      }
    }
  }


  if (!bMulti)
  {
    return IsOneEmpty(vElement, sMessage);
  }
  else
  {
    bGetCountOfEmpties = s_Init(bGetCountOfEmpties, false);
    oForm = document.forms[sFormName];

    
    var i;
    var oNextElement;
    var iCount = 0;
    var iFirstElemIndex = -1;
    var iFirstEmptyElemIndex = -1;


    for (i = 0; i < oForm.elements.length; i++)
    {
      oNextElement = oForm.elements[i];

      if ( s_Left(oNextElement.name, vElement.length) == vElement )
      {
        if (iFirstElemIndex == -1) {iFirstElemIndex = i;}

        if (!IsOneEmpty(oNextElement, "no")) 
        {
          if (!bGetCountOfEmpties) {iCount ++ ;}
        }
        else
        {
          if (iFirstEmptyElemIndex == -1) {iFirstEmptyElemIndex = i;}
          if (bGetCountOfEmpties) {iCount ++ ;}
        }
      }
    }


    if (iFirstElemIndex == -1) 
    {
      return -1;
    }
    else
    {
      bNeedToAlert = (bGetCountOfEmpties) ? iCount > 0 : iCount == 0;
      if (bNeedToAlert)
      {
        ShowMessage(sMessage, g_ReqField);        
        var iFocus = (bGetCountOfEmpties) ? iFirstEmptyElemIndex : iFirstElemIndex;
        oForm.elements[ iFocus ].focus();
      }
      return iCount;
    }
  }
}

//----------------------------------------------------------------

function IsDate(oElem, sFormat, sMsg)
{
  if (oElem.value == "")
  {
    return "";
  }

  sMsg = s_Init(sMsg, g_NeedDate);

//alert(oElem.value);
  
  bResult = dt_Check(oElem.value, sFormat);
  
  if ( !bResult )
  {
    alert(s_Replace(sMsg, "#format#", dt_DecriptFormat(sFormat)));
    oElem.focus();
  }

  return bResult;
}

//-----------------------------------------------------------------

function IsTime(theElem)
{
  result = true;
  aStr = theElem.value;
  count = aStr.length;  

  if( count!=0 )
  {
    result = false;
    
    firstInd = aStr.indexOf(":",0)
    if(firstInd!=-1)
    {
      if( IsIntPriv(aStr.substr(0,firstInd)) )
      {
        s1 = parseInt(s_RemoveLeadZeros(aStr.substr(0,firstInd)));  
        secInd = aStr.indexOf(":",firstInd+1)
        if(secInd!=-1)
        {
          if( (IsIntPriv(aStr.substr(firstInd+1,secInd-firstInd-1))) && (IsIntPriv(aStr.substr(secInd+1,count-secInd-1))) )
          {
            s2 = parseInt(s_RemoveLeadZeros(aStr.substr(firstInd+1,secInd-firstInd-1)));
            s3 = parseInt(s_RemoveLeadZeros(aStr.substr(secInd+1,count-secInd-1)));
            
            if ((s1 < 13)&&(s1>=0)&&(s2<60)&&(s2>=0)&&(s3<60)&&(s3>=0))
              result = true;
          }
        }
      }
    }

    // show error message
    if( !result )
    {
      alert("This field requires a time (hh:mm:ss)!");
      theElem.focus();
    }
  }

  return result;
}

//-----------------------------------------------------------------
function IsLonger(oElem, iLen, bStrict)
{
  bStrict = s_Init (bStrict, bVLD_NOSTRICT);
  
  if (bStrict)
  {
    if (oElem.value.length > iLen) {return true;}
    sMsg = gsMUSTBELONGER_STRICT;
  }
  else
  {
    if (oElem.value.length >= iLen) {return true;}
    sMsg = gsMUSTBELONGER_NOSTRICT;
  }
  
  sMsg = s_Replace(sMsg, "#LEN#", iLen);
  alert(sMsg);
  oElem.focus();
  return false;
}

//-----------------------------------------------------------------

function CheckCheckboxesForDelete(sPrefix, sNoOneCheckedMsg, sShureDeleteMsg, sOperationHiddenElement, iOperationValue)
{
  oForm = event.srcElement.form;
  iCount = IsEmpty (sPrefix, sNoOneCheckedMsg, oForm.name);
  
  if (iCount == 0 )
  {
    return false;
  }
  else
  {
    sShureDeleteMsg = s_Replace (sShureDeleteMsg, "#COUNT#", iCount);
    bResult = confirm(sShureDeleteMsg);
    if (bResult) {oForm.elements[sOperationHiddenElement].value = iOperationValue;}
    return bResult;
  }
}

// private functions ===============================================
function IsIntPriv(theInt)
{
  return theInt==parseInt(s_RemoveLeadZeros(theInt));
}

function IsFloatPriv(theFloat, sParams)
{
  sParams = s_Init(sParams, "");  
  bPozitiveStrict = s_GetPrefix (sParams, sVLD_POZITIVE_STRICT);
  if (bPozitiveStrict) {sMsg = s_CutPrefix(sParams, sVLD_POZITIVE_STRICT);}
  bPozitive = s_GetPrefix (sParams, sVLD_POZITIVE);
  if (bPozitive) {sMsg = s_CutPrefix(sParams, sVLD_POZITIVE);}

  bRes = theFloat == parseFloat(theFloat);
  if (!bRes) {return false;}
  
  iRes = parseFloat(theFloat);
  if (bPozitive && (iRes < 0 ) ) {return false;}
  if (bPozitiveStrict && (iRes <= 0 ) ) {return false;}
  
  return true;
}