////////////////////////////////////////////////////////////////
//  Esta función, recorre TODOS los campos de un formulario
// recibido como argumento y sustitye todas las ocurrencias de
// Los caracteres "<" y "&" por sus correspondientes códigos de
// ESCAPE para que el XML del cual ellos van a formar parte (teóricamente se asume que se van ameter en un XML!),
// sea válido.
////////////////////////////////////////////////////////////////

//____________________________________________________________________________________




function doEscapeFormFields(formulario){

// OJO, este boolean permite mostrar los parámetros que serán enviados al enviar los datos del formulario!
mostrarAlertConParametrosDelFormulario = false;


  //  recorro todos los elementos que tiene el formulario recibido para hacer la sustitución de los caracteres "<" y "&" !
   for (i = 0; i < formulario.length; i++){


      if (!(formulario.elements[i].value == null) ){

      //   formulario.elements[i].value = getReplacedString ("&", "&#38;", formulario.elements[i].value);
      //   formulario.elements[i].value = getReplacedString ("<", "&#60;", formulario.elements[i].value);


     }

   }

// ------------------Esto es solo para mostrar un alert con los datos del formulario
// Esta parte se ejecutará en dependencia del valor que tenga el boolean mostrarAlertConParametrosDelFormulario !!
if (mostrarAlertConParametrosDelFormulario){
   str = "";
   for (i = 0; i < formulario.length; i++){
      str = str + formulario.elements[i].name + " = " + formulario.elements[i].value +"\n";
    }
      alert("Datos del formulario que serán enviados:\n\n" + str);
   }
// ---------------hasta aqui llega lo de mostrar los datos del formulario cuando mostrarAlertConParametrosDelFormulario sea true!!


}

function assignFileNameOnly(inputFileItem, hiddenHiddenItem) {
// Receives an Input of File type and a hidden input.
// Will get the fileName Only and will assign it to the hiddenItem

//si se recibe "D:\files\Fotos\Mary Jose\P3080019.JPG"
//me quedo solo con "P3080019.JPG"

// Busco de atras hacia adelante el primer caracter "\"  y tomo el valor de ahi en adelante solamente!

  for (var i=inputFileItem.value.length-1; i>=0; i--) {

     if (inputFileItem.value.substring(i,i+1) == "\\") {
        hiddenHiddenItem.value = inputFileItem.value.substring(i+1,inputFileItem.value.length);
        return;
      }
   }

}


////////////////////////////////////////////////////////////////////////
// Esta es una implementación de un replace porque la String de JavaScript NO tiene una
// se llama asi:  replaceString("World","Web","Brave New World")
// tomado de http://wp.netscape.com/eng/mozilla/3.0/handbook/javascript/ref_s-s.htm
////////////////////////////////////////////////////////////////////////
function getReplacedString(oldS,newS,fullS) {
// Replaces oldS with newS in the string fullS
  for (var i=0; i<fullS.length; i++) {
     if (fullS.substring(i,i+oldS.length) == oldS) {
        fullS = fullS.substring(0,i)+newS+fullS.substring(i+oldS.length,fullS.length)
      }
   }
 return fullS
}


// ********************  Validación de un campo TEXTO recibiendo ademñás una cadena descriptiva!
//
// Recibe:   Permite validar campos INPUT TEXT de Textos en formularios
// inputField     --el objeto Input Text del formulario
// emptyAllowed   --un boolean indicando true si se permite que el campo sea VACIO, false si el campo tiene que tomar valores!
// TextIdentifier --Cadena con el texto que describe este campo INPUT. Se toma para emitir los mensajes de errores por tanto debe ser algo como "la cantidad de personas que viven en la casa" para el INPUT correspondiente!

// Retorna:  boolean correspondiente a si ha sido validado correctamente el campo recibido!

function validateTextInputField (inputField,
                                    emptyAllowed,
                                    textIdentifier ){

    // Tomo la cadena que contiene el texto del Input recibido!
    inputStringValue = trim(inputField.value);

if ( (!emptyAllowed) & (inputStringValue == "")){
		 // Si NO se permite que el campo sea vacío y el campo es vacio,
         // entonces HAY PROBLEMAS, por lo que saco una ventana de error y retorno false!
         alert ("El valor de " + textIdentifier + " no puede ser vacío.");
         inputField.focus();
         return false;
       }

   return true;

}


// ********************  Validación de un campo TEXTO recibiendo ademñás una cadena descriptiva MAIL!
//
// Recibe:   Permite validar campos INPUT TEXT de Textos MAIL  en formularios
// inputField     --el objeto Input Text del formulario
// emptyAllowed   --un boolean indicando true si se permite que el campo sea VACIO, false si el campo tiene que tomar valores!
// TextIdentifier --Cadena con el texto que describe este campo INPUT. Se toma para emitir los mensajes de errores por tanto debe ser algo como "la cantidad de personas que viven en la casa" para el INPUT correspondiente!

// Retorna:  boolean correspondiente a si ha sido validado correctamente el campo recibido!

function validateMAILTextInputField (inputField,
                                    emptyAllowed,
                                    textIdentifier ){

    // Tomo la cadena que contiene el texto del Input recibido!
    inputStringValue = trim(inputField.value);

if ( (!emptyAllowed) & (inputStringValue == "")){
		 // Si NO se permite que el campo sea vacío y el campo es vacio,
         // entonces HAY PROBLEMAS, por lo que saco una ventana de error y retorno false!
         alert ("El valor de " + textIdentifier + " no puede ser vacío.");
         inputField.focus();
         return false;
       }
	   
if (inputField.value.indexOf('@', 0) == -1 || inputField.value.indexOf('.', 0) == -1)
  	{ alert("Dirección de e-mail inválida"); 
		inputField.focus(); 
		return false; }
return true;
}
// ********************  Validación de un campo TEXTO recibiendo ademñás una cadena descriptiva!
//
// Recibe:   Permite validar campos INPUT TEXT de Textos en formularios
// inputField     --el objeto Input Text del formulario
// emptyAllowed   --un boolean indicando true si se permite que el campo sea VACIO, false si el campo tiene que tomar valores!
// TextIdentifier --Cadena con el texto que describe este campo INPUT. Se toma para emitir los mensajes de errores por tanto debe ser algo como "la cantidad de personas que viven en la casa" para el INPUT correspondiente!

// Retorna:  boolean correspondiente a si ha sido validado correctamente el campo recibido!

function validateTextInputFieldEnglish (inputField,
                                    emptyAllowed,
                                    textIdentifier ){

    // Tomo la cadena que contiene el texto del Input recibido!
    inputStringValue = trim(inputField.value);


    if ( (!emptyAllowed) & (inputStringValue == "")){
         // Si NO se permite que el campo sea vacío y el campo es vacio,
         // entonces HAY PROBLEMAS, por lo que saco una ventana de error y retorno false!
         alert ("The value for " + textIdentifier + " cannot be empty.");
         inputField.focus();
         return false;
       }

   return true;

}



// ********************  Validación de un campo numérico DECIMAL solamente recibiendo ademñás una cadena descriptiva!
//
// Recibe:   Permite validar INPUT TEXT de formularios solo para valores ENTEROS dado un rango de valores!
// inputField     --el objeto Input Text del formulario
// emptyAllowed   --un boolean indicando true si se permite que el campo sea VACIO, false si el campo tiene que tomar valores!
// zeroAllowed    --un boolean indicando true si se permite que en el campo se introduzca el valor CERO, y false si el campo NO Puede ser cero!
// minAllowed     --valor numérico mínimo que se le permite tomar a este campo!
// maxAllowed     --valor numérico mínimo que se le permite tomar a este campo!
// TextIdentifier --Cadena con el texto que describe este campo INPUT. Se toma para emitir los mensajes de errores por tanto debe ser algo como "la cantidad de personas que viven en la casa" para el INPUT correspondiente!

// Retorna:  boolean correspondiente a si ha sido validado correctamente el campo recibido!

function validateNumericDecimalInputField  (inputField,
                                    emptyAllowed,
                                    zeroAllowed,
                                    minAllowed,
                                    maxAllowed,
                                    textIdentifier ){

    var numDecimalPattern = /^[.1234567890]+$/g;


    // Tomo la cadena que contiene el texto del Input recibido!
    inputStringValue = trim(inputField.value);




      if ( (emptyAllowed) & (inputStringValue == "")){
         // Si se permite que el campo sea vacío y el campo es vacio,
         // entonces OK, no hay problema, retorno TRUE y ademas...

         // OJO; si además se permite que tome valor CERO, LE ASIGNO CERO al INPUT !!!!!
         if (zeroAllowed){

             inputField.value = "0";
          }

        return true;

      }


      if ( (!emptyAllowed) & (inputStringValue == "")){
           // Si no se permite que el campo sea vacio y ES vacio entonces ERROR!
           alert("Debe introducir " + textIdentifier + ".");
           inputField.focus();
           return false;
      }



        // Validar si tiene un formato numérico valido!


      if( !inputStringValue.match (numDecimalPattern)){
           alert ("El valor de " + textIdentifier + ", no tiene un formato numérico válido.\n\nNOTA: No se permite separar las cantidades de miles con comas ',' \ny si desea introducir decimales, debe usar un punto '.'");
           inputField.focus();
           return false;
      }


    // Tomo el valor de tipo Entero de lo que se ha introducido en el Input
    integerValue = parseInt(inputField.value);


        if ((!zeroAllowed) & (integerValue == 0)) {
           alert ("El valor de " + textIdentifier + " no puede ser cero.");
           inputField.focus();
           return false;
         }

        if (integerValue < minAllowed) {
           alert ("El valor de " + textIdentifier + " no puede ser menor que " + minAllowed);
           inputField.focus();
           return false;
         }

        if (integerValue > maxAllowed) {
           alert ("El valor de " + textIdentifier + " no puede ser mayor que " + maxAllowed);
           inputField.focus();
           return false;
         }

    // si se llega al final quiere decir que se ha validado correctamente!
    // entonces le asigno al valor del INPUT, su valor sin LOS ESPACIOS EN BLANCO delante y detras !

    inputField.value = inputStringValue;  // Notese que al inicio de aqui, se hizo: inputStringValue = trim(inputField.value);
    return true;

 }



// ********************  Validación de un campo numérico DECIMAL solamente recibiendo ademñás una cadena descriptiva!
//
// Recibe:   Permite validar INPUT TEXT de formularios solo para valores ENTEROS dado un rango de valores!
// inputField     --el objeto Input Text del formulario
// emptyAllowed   --un boolean indicando true si se permite que el campo sea VACIO, false si el campo tiene que tomar valores!
// zeroAllowed    --un boolean indicando true si se permite que en el campo se introduzca el valor CERO, y false si el campo NO Puede ser cero!
// minAllowed     --valor numérico mínimo que se le permite tomar a este campo!
// maxAllowed     --valor numérico mínimo que se le permite tomar a este campo!
// TextIdentifier --Cadena con el texto que describe este campo INPUT. Se toma para emitir los mensajes de errores por tanto debe ser algo como "la cantidad de personas que viven en la casa" para el INPUT correspondiente!

// Retorna:  boolean correspondiente a si ha sido validado correctamente el campo recibido!

function validateNumericDecimalInputFieldInEnglish  (inputField,
                                    emptyAllowed,
                                    zeroAllowed,
                                    minAllowed,
                                    maxAllowed,
                                    textIdentifier ){

    var numDecimalPattern = /^[.1234567890]+$/g;


    // Tomo la cadena que contiene el texto del Input recibido!
    inputStringValue = trim(inputField.value);




      if ( (emptyAllowed) & (inputStringValue == "")){
         // Si se permite que el campo sea vacío y el campo es vacio,
         // entonces OK, no hay problema, retorno TRUE y ademas...

         // OJO; si además se permite que tome valor CERO, LE ASIGNO CERO al INPUT !!!!!
         if (zeroAllowed){

             inputField.value = "0";
          }

        return true;

      }


      if ( (!emptyAllowed) & (inputStringValue == "")){
           // Si no se permite que el campo sea vacio y ES vacio entonces ERROR!
           alert(textIdentifier + "cannot be empty.");
           inputField.focus();
           return false;
      }



        // Validar si tiene un formato numérico valido!


      if( !inputStringValue.match (numDecimalPattern)){
           alert ( textIdentifier + ", does not have a valid numeric format.\n\nNOTE: It is not allowed to use ',' for separating the thousands units \nand if you want to use decimals, you must use a dot '.'");
           inputField.focus();
           return false;
      }


    // Tomo el valor de tipo Entero de lo que se ha introducido en el Input
    integerValue = parseInt(inputField.value);


        if ((!zeroAllowed) & (integerValue == 0)) {
           alert ( textIdentifier + " cannot be zero.");
           inputField.focus();
           return false;
         }

        if (integerValue < minAllowed) {
           alert ( textIdentifier + " cannot be lower than " + minAllowed);
           inputField.focus();
           return false;
         }

        if (integerValue > maxAllowed) {
           alert ( textIdentifier + " cannot be higher than " + maxAllowed);
           inputField.focus();
           return false;
         }

    // si se llega al final quiere decir que se ha validado correctamente!
    // entonces le asigno al valor del INPUT, su valor sin LOS ESPACIOS EN BLANCO delante y detras !

    inputField.value = inputStringValue;  // Notese que al inicio de aqui, se hizo: inputStringValue = trim(inputField.value);
    return true;

 }









// ********************  Validación de un campo numérico ENTERO solamente recibiendo ademñás una cadena descriptiva!
//
// Recibe:   Permite validar INPUT TEXT de formularios solo para valores ENTEROS dado un rango de valores!
// inputField     --el objeto Input Text del formulario
// emptyAllowed   --un boolean indicando true si se permite que el campo sea VACIO, false si el campo tiene que tomar valores!
// zeroAllowed    --un boolean indicando true si se permite que en el campo se introduzca el valor CERO, y false si el campo NO Puede ser cero!
// minAllowed     --valor numérico mínimo que se le permite tomar a este campo!
// maxAllowed     --valor numérico mínimo que se le permite tomar a este campo!
// TextIdentifier --Cadena con el texto que describe este campo INPUT. Se toma para emitir los mensajes de errores por tanto debe ser algo como "la cantidad de personas que viven en la casa" para el INPUT correspondiente!

// Retorna:  boolean correspondiente a si ha sido validado correctamente el campo recibido!

function validateNumericIntegerInputField  (inputField,
                                    emptyAllowed,
                                    zeroAllowed,
                                    minAllowed,
                                    maxAllowed,
                                    textIdentifier ){


    var numIntegerPattern = /^[1234567890]+$/g;


    // Tomo la cadena que contiene el texto del Input recibido!
    inputStringValue = trim(inputField.value);




      if ( (emptyAllowed) & (inputStringValue == "")){
         // Si se permite que el campo sea vacío y el campo es vacio,
         // entonces OK, no hay problema, retorno TRUE y ademas...

         // OJO; si además se permite que tome valor CERO, LE ASIGNO CERO al INPUT !!!!!
         if (zeroAllowed){

             inputField.value = "0";
          }

        return true;

      }


      if ( (!emptyAllowed) & (inputStringValue == "")){
           // Si no se permite que el campo sea vacio y ES vacio entonces ERROR!
           alert("Debe introducir " + textIdentifier + ".");
           inputField.focus();
           return false;
      }



        // Validar si tiene un formato numérico valido!


      if( !inputStringValue.match (numIntegerPattern)){
           alert ("El valor de " + textIdentifier + ", no tiene un formato numérico entero válido.\nEl campo no puede incluir puntos ni comas.");
           inputField.focus();
           return false;
      }


    // Tomo el valor de tipo Entero de lo que se ha introducido en el Input
    integerValue = parseInt(inputField.value);


        if ((!zeroAllowed) & (integerValue == 0)) {
           alert ("El valor de " + textIdentifier + " no puede ser cero.");
           inputField.focus();
           return false;
         }

        if (integerValue < minAllowed) {
           alert ("El valor de " + textIdentifier + " no puede ser menor que " + minAllowed);
           inputField.focus();
           return false;
         }

        if (integerValue > maxAllowed) {
           alert ("El valor de " + textIdentifier + " no puede ser mayor que " + maxAllowed);
           inputField.focus();
           return false;
         }

    // si se llega al final quiere decir que se ha validado correctamente!
    // entonces le asigno al valor del INPUT, su valor sin LOS ESPACIOS EN BLANCO delante y detras !

    inputField.value = inputStringValue;  // Notese que al inicio de aqui, se hizo: inputStringValue = trim(inputField.value);
    return true;

 }




 // ********************  Validación de un campo numérico ENTERO solamente recibiendo ademñás una cadena descriptiva!
 //
 // Recibe:   Permite validar INPUT TEXT de formularios solo para valores ENTEROS dado un rango de valores!
 // inputField     --el objeto Input Text del formulario
 // emptyAllowed   --un boolean indicando true si se permite que el campo sea VACIO, false si el campo tiene que tomar valores!
 // zeroAllowed    --un boolean indicando true si se permite que en el campo se introduzca el valor CERO, y false si el campo NO Puede ser cero!
 // minAllowed     --valor numérico mínimo que se le permite tomar a este campo!
 // maxAllowed     --valor numérico mínimo que se le permite tomar a este campo!
 // TextIdentifier --Cadena con el texto que describe este campo INPUT. Se toma para emitir los mensajes de errores por tanto debe ser algo como "la cantidad de personas que viven en la casa" para el INPUT correspondiente!

 // Retorna:  boolean correspondiente a si ha sido validado correctamente el campo recibido!

 function validateNumericIntegerInputFieldInEnglish  (inputField,
                                     emptyAllowed,
                                     zeroAllowed,
                                     minAllowed,
                                     maxAllowed,
                                     textIdentifier ){


     var numIntegerPattern = /^[1234567890]+$/g;


     // Tomo la cadena que contiene el texto del Input recibido!
     inputStringValue = trim(inputField.value);




       if ( (emptyAllowed) & (inputStringValue == "")){
          // Si se permite que el campo sea vacío y el campo es vacio,
          // entonces OK, no hay problema, retorno TRUE y ademas...

          // OJO; si además se permite que tome valor CERO, LE ASIGNO CERO al INPUT !!!!!
          if (zeroAllowed){

              inputField.value = "0";
           }

         return true;

       }


       if ( (!emptyAllowed) & (inputStringValue == "")){
           // Si no se permite que el campo sea vacio y ES vacio entonces ERROR!
           alert(textIdentifier + "cannot be empty.");
           inputField.focus();
           return false;
       }



        // Validar si tiene un formato numérico valido!


       if( !inputStringValue.match (numIntegerPattern)){
           alert ( textIdentifier + ", does not have a valid numeric format.");
           inputField.focus();
           return false;
       }


     // Tomo el valor de tipo Entero de lo que se ha introducido en el Input
     integerValue = parseInt(inputField.value);


        if ((!zeroAllowed) & (integerValue == 0)) {
           alert ( textIdentifier + " cannot be zero.");
           inputField.focus();
           return false;
         }

        if (integerValue < minAllowed) {
           alert ( textIdentifier + " cannot be lower than " + minAllowed);
           inputField.focus();
           return false;
         }

        if (integerValue > maxAllowed) {
           alert ( textIdentifier + " cannot be higher than " + maxAllowed);
           inputField.focus();
           return false;
         }

     // si se llega al final quiere decir que se ha validado correctamente!
     // entonces le asigno al valor del INPUT, su valor sin LOS ESPACIOS EN BLANCO delante y detras !

     inputField.value = inputStringValue;  // Notese que al inicio de aqui, se hizo: inputStringValue = trim(inputField.value);
     return true;

  }








// validateCurrencyInputField, valida que el campo recibido como parámetro, inputField, sea un valor de moneda con solo dos decimales!
 function validateCurrencyInputField(inputField,
                                     emptyAllowed,
                                     zeroAllowed,
                                     minAllowed,
                                     maxAllowed,
                                     textIdentifier ){


     if (!validateNumericDecimalInputField(inputField,
                                     emptyAllowed,
                                     zeroAllowed,
                                     minAllowed,
                                     maxAllowed,
                                     textIdentifier ) ){

          return false;

             }


        var positionOfPoint = inputField.value.indexOf(".")

      if (positionOfPoint == -1){
          // Ok, aqui en el campo moneda NO se ha encontrado el char punto, entonces es válido este numero!!
         return true;
        }


 // Calculo la cantidad de cifras que hay despues de la coma ( punto )!
        var charsAfterPoint = inputField.value.length - 1 - positionOfPoint;


    if (charsAfterPoint > 2){

      alert ("El campo " + textIdentifier + ", no puede tener más de dos valores decimales.");
      inputField.focus();
      return false;

    }else{

       //OK; aqui el campo tiene menos o exactamente 2 decimales !!
      return true;

    }

    return true;

 }






 // validateCurrencyInputFieldInEnglish, valida que el campo recibido como parámetro, inputField, sea un valor de moneda con solo dos decimales!
  function validateCurrencyInputFieldInEnglish(inputField,
                                      emptyAllowed,
                                      zeroAllowed,
                                      minAllowed,
                                      maxAllowed,
                                      textIdentifier ){


      if (!validateNumericDecimalInputFieldInEnglish(inputField,
                                      emptyAllowed,
                                      zeroAllowed,
                                      minAllowed,
                                      maxAllowed,
                                      textIdentifier ) ){

           return false;

              }


         var positionOfPoint = inputField.value.indexOf(".")

       if (positionOfPoint == -1){
           // Ok, aqui en el campo moneda NO se ha encontrado el char punto, entonces es válido este numero!!
          return true;
         }


  // Calculo la cantidad de cifras que hay despues de la coma ( punto )!
         var charsAfterPoint = inputField.value.length - 1 - positionOfPoint;


     if (charsAfterPoint > 2){

       alert (textIdentifier + ", cannot have more than two decimal figures.");
       inputField.focus();
       return false;

     }else{

        //OK; aqui el campo tiene menos o exactamente 2 decimales !!
       return true;

     }

     return true;

 }




 //////////////////////////////////////////////////////////////////////
 //
 // Esta función elimina los espacios en blanco al principio y al final
 // de la cadena de caracteres pasada como parámetros. By Sergio!
 //
 //////////////////////////////////////////////////////////////////////

 function trim (cadena) {
        // Quitamos los espacios en blanco de delante y detrás de la cadena.
        cadena = cadena.replace (/^\s+/, '');
        cadena = cadena.replace (/\s+$/, '');

        return cadena;
 }





//////////////////////////////////////////////////////////////////////
//
// Esta función recibe un valor numerico y devuelve una cadena
// con el valor numerico redondeado a dos decimales!
//
//////////////////////////////////////////////////////////////////////

  function getRoundedString (n) {
    n = Math.round(n * 100) / 100;
    n = (n + 0.001) + '';
    return n.substring(0, n.indexOf('.') + 3);
  }


  ////////////////////////////////////////////////////////////////////
  //
  // Parametros:
  // selectObject:  elemento de tipo SELECT de un formulario
  // matchString:   Cadena que con el texto a buscar en el selectObject
  //
  // Esta función recibe un elemento SELECT de un formulario, y una CADENA
  // y realiza una búsqueda en LAS OPTIONS DEL SELECT y marca como
  // SELECTED= true a la OPTION cuyo VALUE sea igual a la cadena recibida
  //
  ////////////////////////////////////////////////////////////////////
  function doMatchSelectWithString(selectObject, matchString){

    // Tomo de una vez, la cadena sin espacios para no tener que quitarle los espacios en cada pregunta del "if" en el ciclo a continuación!
    trimmedMatchString = trim(matchString);

    for (i = 0; i < selectObject.options.length; i++){
     if (trim(selectObject.options[i].value) == trimmedMatchString){
      selectObject.options[i].selected = true;
      //Aqui en el primero que me encuentre, salgo!
      return true;
     }

    }


    selectObject.options[0].selected = true;
    return false;

  }


  function doMatchSelectWithStringByName(selectObject, matchString){

      // Tomo de una vez, la cadena sin espacios para no tener que quitarle los espacios en cada pregunta del "if" en el ciclo a continuación!
      trimmedMatchString = trim(matchString);

      for (i = 0; i < selectObject.options.length; i++){
       if (trim(selectObject.options[i].name) == trimmedMatchString){
        selectObject.options[i].selected = true;
        //Aqui en el primero que me encuentre, salgo!
        return true;
       }

      }


      selectObject.options[0].selected = true;
      return false;

  }


// /////////////////////////////////////////////////*
//    VALIDAR UN AFECHA!!


function fechaEsValida (diaInput, mesInput, anioInput, textoNombreFormularioParaMensaje){

        var dia  = trim(diaInput.value);
        var mes  = trim(mesInput.value);
        var anio = trim(anioInput.value);

// ********************   DIA

        if (dia == ""){
                alert("Debe introducir el dia de " + textoNombreFormularioParaMensaje);
                diaInput.focus();
                return false;
        }else {

                  dia = parseInt(dia);

                  if ( (dia <= 0) || (dia > 31)){
                         alert ("El dia de la fecha de "+ textoNombreFormularioParaMensaje + " debe estar entre 1 y 31.");
                         diaInput.focus();
                         return false;
                      }


           }

// ********************   MES

        if (mes ==""){
                alert("Debe introducir el mes de " + textoNombreFormularioParaMensaje);
                mesInput.focus();
                return false;
        }else {

                  mes = parseInt(mes);
                  if ( (mes <= 0) || (mes > 12)){
                         alert ("El mes de la fecha de "+ textoNombreFormularioParaMensaje +"  debe estar entre 1 y 12. ");
                         mesInput.focus();
                         return false;
                      }


           }

// ********************   AÑO
        if (anio ==""){
                alert("Debe introducir el año de " + textoNombreFormularioParaMensaje);
                anioInput.focus();
                return false;
        }else {

                   anio = parseInt(anio);

                  if (anio <= 0) {
                         alert ("El año de "+ textoNombreFormularioParaMensaje + " debe ser al menos un valor positivo.");
                         anioInput.focus();
                         return false;
                      }


           }


       // *********** OJO, ahora valido que los dias no sean mayores que la cantidad
       // de dias que admite el mes seleccionado!
       // Valido que Febrero no tenga mas de 29 dias y que ademas si el dia es 31,
       // entonces el mes no puede ser [4,6,9,11] !!
       if ( ((dia > 29) && (mes == 2))        ||
            ((dia == 31) && (  (mes==4 || mes==6 || mes==9 || mes==11 ) ))    ){

          alert ("En la fecha de " + textoNombreFormularioParaMensaje + ", el mes "+ mes + " no es valido que tenga "+ dia + " dias. ");
          diaInput.focus();
          return false;

       }


// Si se llega al final, es que la fecha recibida es válida asi que se devuelve true!!!
return true;

}





//////////////////////////////////////////////////////////////////////
//
// Esta función recibe una CADENA con un valor (supuestamente) numérico
// y devuelve una cadena  con el valor numerico redondeado
// a dos decimales!
//
//////////////////////////////////////////////////////////////////////

  function getRoundedStringFromString (stringContainingANumber) {

   // Calculo el valor numérico que tiene la cadena recibida!
    var numericValue = parseFloat(trim(stringContainingANumber));

    numericValue = Math.round(numericValue * 100) / 100;
    numericValue = (numericValue + 0.001) + '';

    return numericValue.substring(0, numericValue.indexOf('.') + 3);

  }





function getSelectedValueOfRadio(radioElement) {
  if (radioElement[0]){
     for (i = 0; i <  radioElement.length; i++){

       if (radioElement[i].checked){

         valueSelected = radioElement[i].value;

       }

     }
   }
   else{

    valueSelected = radioElement.value;

    }

    return valueSelected;

 }




 // VSU 30 dic 2002. Esta funcion recibe un objeto SELECT y elimina del mismo todos sus OPTIONS
 function deleteAllOptionsInSelect(selectItem){

   if ((selectItem != null) && (selectItem.options != null)) {
      while (selectItem.options.length) {
        selectItem.options[0] = null;
      }
    }
}



// cloneSelectItem recibe dos elementos SELECT de un formulario y lo que hace es clonar uno de ellos, es decir, le crea al select Destino, un OPTION exactamente igual por cada OPTION que está presente en el SELECT Source!
// NOTA, solo se está asumiendo que cada OPTION tiene los atributos: value, name y text.
function cloneSelectItem(selectSource, selectDest){

    // Elimino todos los OPTIONS que tiene el selectDest para crearle los nuevos OPTIONS que son copia de los options del selectSource
    deleteAllOptionsInSelect(selectDest);

    if ((selectSource != null) && (selectSource.options != null)) {
       for (i = 0; i < selectSource.options.length; i++){

             // creo el option [i] en el select destino!
            selectDest.options[selectDest.options.length ] = new Option();

            //Se asignan los siguientes atributos al option que se ha creado en el select destino.
            selectDest[i].value = selectSource[i].value;
            selectDest[i].name = selectSource[i].name;
            selectDest[i].text = selectSource[i].text;

            selectDest[i].selected = selectSource[i].selected;
         }// for
    } //if

}

//----------------------------------------------------------------------
//Para conservar los datos de la busqueda en los listados.


function cargarID(VALUE)
{
	document.form_datos.all('id').value=VALUE;
	document.form_datos.submit();
}