function ValidDate(InputDate) { 
	//InputDate is not empty
	if (InputDate == "") {
		alert("la fecha esta vacía");
		return (false);
	}

	//InputDate must be in format dd/mm/yyyy
	if ((InputDate.substring(2, 3) != "/") || (InputDate.substring(5, 6) != "/")) {
		return (false);
	}

	//validate numeric data
	day = InputDate.substring(0, 2);
	month = InputDate.substring(3, 5);
	year = InputDate.substring(6, 10);
	if (isNaN(day) || isNaN(month) || isNaN(year)) {
		return (false);
	}

	//validate correct date
	day_n = parseInt(day, 10);
	month_n = parseInt(month, 10);
	year_n = parseInt(year, 10);
	if (year_n < 1000 || year_n > 2100) {
		return (false);
	}
	if (month_n < 1 || month_n > 12) {
		return (false);
	}
	if ((day_n < 1) || (day_n > 31)) {
		alert("el dia no es correcto");
		return (false);
	}	
	if ((day_n == 31) && ((month_n == 2) || (month_n == 4) || (month_n == 6) || (month_n == 9) || (month_n == 11))) {
		return (false);
	}	
	if ((day_n == 30) && (month_n == 2)) {
		return (false);
	}	
	if ((day_n == 29) && (month_n == 2) && (year_n % 4 != 0)) {
		return (false);
	}

	return (true);
}


////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// devuelve True/false si el valor es entero
function IsInteger(s) {
	if (s.length==0){
		return false;
	}
	for (var i = 0; i < s.length; i++) {
		var c = s.charAt(i);
		if (!((c >= "0") && (c <= "9"))) {
			return false;
		}
	}
	return true;
}

////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//---- funciones para escribir decimales  en campos de texto --------//
function validarDecimal(event,txtCampo) // escribir en un campo texto solo valores decimales
{
	var navegador = navigator.appName 
	var ac;
	//no utilizo el name ya tengo la referencia del text
	var texto = txtCampo.value;

	ac = teclaEvento(event); 
	//if ((ac >= 48) && (ac <= 57) || (ac == 44) || (ac == 46) || (ac == 13) || (ac == 8) || (ac == 9)) {
	if ((ac >= 48) && (ac <= 57) || (ac == 44) ||  (ac == 13) || (ac == 8) || (ac == 9)) {
	}
	else { 
		//if (ac == 46) {
		///en fire fox no puedes cambiar el codigo de la tecla
		///o no lo he visto lo que puedes hacer es cancelar el evento
		///window.event.keyCode = ac - 2;
		//continuarEvento(event,false)
		//}
		//else { 
			if (ac == 13) {
			window.lnkIntro.click(); 
			}
			else {
				if (navegador == "Microsoft Internet Explorer") {
					window.event.keyCode = " ";
				}
				else{				
					//esta funcion te garantiza que canceles el evento tanto en ie como en ff
				    return continuarEvento(event,false);
				} // fin navegador
			}
		// } 
	//document.forms.item(0).item(txtCampo).value = texto; 
	texto = "";
	}
//} 
} 


//function escribeMoneda(){
//	alert(event.keyCode);
//	if (event.keyCode < 48 || event.keyCode > 57) 
//		event.returnValue = false;
//}


function teclaEvento(evento){ 
	if (evento.keyCode)
		return evento.keyCode;
	else
		return evento.which;
} 

function continuarEvento(evento,continuar){ 
	if (evento.preventDefault && !continuar){
		evento.preventDefault();
		evento.stopPropagation();
	} 
	return continuar;
}
//---- funciones para escribir decimales  en campos de texto --------//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////




////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// Changes:  Sandeep V. Tamhankar (stamhankar@hotmail.com)

/* 1.1.2: Fixed a bug where trailing . in e-mail address was passing
            (the bug is actually in the weak regexp engine of the browser; I
            simplified the regexps to make it work).
   1.1.1: Removed restriction that countries must be preceded by a domain,
            so abc@host.uk is now legal.  However, there's still the 
            restriction that an address must end in a two or three letter
            word.
     1.1: Rewrote most of the function to conform more closely to RFC 822.
     1.0: Original  */

function emailCheck (emailStr) {
/* The following pattern is used to check if the entered e-mail address
   fits the user@domain format.  It also is used to separate the username
   from the domain. */
var emailPat=/^(.+)@(.+)$/
/* The following string represents the pattern for matching all special
   characters.  We don't want to allow special characters in the address. 
   These characters include ( ) < > @ , ; : \ " . [ ]    */
var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
/* The following string represents the range of characters allowed in a 
   username or domainname.  It really states which chars aren't allowed. */
var validChars="\[^\\s" + specialChars + "\]"
/* The following pattern applies if the "user" is a quoted string (in
   which case, there are no rules about which characters are allowed
   and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
   is a legal e-mail address. */
var quotedUser="(\"[^\"]*\")"
/* The following pattern applies for domains that are IP addresses,
   rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal
   e-mail address. NOTE: The square brackets are required. */
var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
/* The following string represents an atom (basically a series of
   non-special characters.) */
var atom=validChars + '+'
/* The following string represents one word in the typical username.
   For example, in john.doe@somewhere.com, john and doe are words.
   Basically, a word is either an atom or quoted string. */
var word="(" + atom + "|" + quotedUser + ")"
// The following pattern describes the structure of the user
var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
/* The following pattern describes the structure of a normal symbolic
   domain, as opposed to ipDomainPat, shown above. */
var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")


/* Finally, let's start trying to figure out if the supplied address is
   valid. */

/* Begin with the coarse pattern to simply break up user@domain into
   different pieces that are easy to analyze. */
var matchArray=emailStr.match(emailPat)
if (matchArray==null) {
  /* Too many/few @'s or something; basically, this address doesn't
     even fit the general mould of a valid e-mail address. */
	alert(emailStr+" Su E-mail es incorrecto (revise @ and .'s)")
	return false
}
var user=matchArray[1]
var domain=matchArray[2]

// See if "user" is valid 
if (user.match(userPat)==null) {
    // user is not valid
    alert(emailStr+"El nombre de usuario no es correcto.")
    return false
}

/* if the e-mail address is at an IP address (as opposed to a symbolic
   host name) make sure the IP address is valid. */
var IPArray=domain.match(ipDomainPat)
if (IPArray!=null) {
    // this is an IP address
	  for (var i=1;i<=4;i++) {
	    if (IPArray[i]>255) {
	        alert(emailStr+" la IP de destino no es valida!")
		return false
	    }
    }
    return true
}

// Domain is symbolic name
var domainArray=domain.match(domainPat)
if (domainArray==null) {
	alert(emailStr+"El dominio no es valido.")
    return false
}

/* domain name seems valid, but now make sure that it ends in a
   three-letter word (like com, edu, gov) or a two-letter word,
   representing country (uk, nl), and that there's a hostname preceding 
   the domain or country. */

/* Now we need to break up the domain to get a count of how many atoms
   it consists of. */
var atomPat=new RegExp(atom,"g")
var domArr=domain.match(atomPat)
var len=domArr.length
if (domArr[domArr.length-1].length<2 || 
    domArr[domArr.length-1].length>3) {
   // the address must end in a two letter or three letter word.
   alert(emailStr+" The address must end in a three-letter domain, or two letter country.")
   return false
}

// Make sure there's a host name preceding the domain.
if (len<2) {
   var errStr=emailStr+ "This address is missing a hostname!"
   alert(errStr)
   return false
}

// If we've gotten this far, everything's valid!
return true;
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// VALIDAR NIF /////////////////
function verifyNif(sNif) { 
	var strLetras = 'TRWAGMYFPDXBNJZSQVHLCKE'; 
	var Letra; 
	sNif=sNif.toUpperCase(); 
	if(sNif.length<9) 
		return(false); 
	else 
	{ 
	Letra=sNif.charAt(sNif.length-1); 
	if(Letra<'A' || Letra>'Z') 
	return(false); 
	else 
		Letra=strLetras.charAt((sNif.substr(0,sNif.length-1))%23); 
		if(sNif.charAt(sNif.length-1)==Letra)	return(true); else	return(false); 
		} 
} 
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////




////////////////////////////////////////////////////////////////////
////////////// Validar cif //////////////////////////
function cif(cif)
{
par = 0
non = 0
letras="ABCDEFGHKLMNPQS"
let=cif.charAt(0)

if (!isNaN(let))
  {
  nif=cif
  validar(nif)
  return false
  }

if (cif.length!=9)
  {
  alert('El Cif debe tener 9 dígitos')
  return false
  }

if (letras.indexOf(let.toUpperCase())==-1)
  {
  alert("El comienzo del Cif no es válido")
  return false
  }

for (zz=2;zz<8;zz+=2)
  {
  par = par+parseInt(cif.charAt(zz))
  }

for (zz=1;zz<9;zz+=2)
  {
  nn = 2*parseInt(cif.charAt(zz))
  if (nn > 9) nn = 1+(nn-10)
  non = non+nn
}

parcial = par + non

control = (10 - ( parcial % 10))

if (control!=cif.charAt(8))
  {
  alert("El Cif no es válido")
  return false
  }
//alert("El Cif es válido");
return true;
}

// validar NIF -CIF
function validarNIFCIF(abc){
PosPrim=abc.charAt(0);
PosUlt=abc.charAt(abc.length-1);
/////////////////////////////
////////////////////////////
if (abc.length==9){
if (!isNaN(PosPrim) && isNaN(PosUlt) ){ //1_________H
	//alert("Posible NIF");	
	if (verifyNif(abc)==false){
		alert("Inserte correctamente el NIF");
		return false;		
	}
	else{
		return true;
	}
}

if (isNaN(PosPrim) && !isNaN(PosUlt) ) { // B__________1
	//alert("Posible CIF");
	if(cif(abc)== false){
		alert("Inserte correctamente el CIF");
		return false;
	}
	else{
		return true;
	}
}
}
else{
	return false;
}
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// ---- Proceso para pasar de un selectmultiple a otro --------------
//----------------------------------------------------------------
function mover(origen, destino,ordenado) {
/* FUNCIONA PARA ie Y fIREFOX 
var bIE = navigator.appName=="Microsoft Internet Explorer";
if (!bIE) {
	alert('Esta función sólo es operativa para Internet Explorer 5.0 y superiores')
}
*/
var arrorigen = new Array();
var arrdestino = new Array();
var arrtemporal = new Array();
var i;


//if (bIE) {
for (i = 0; i < destino.options.length; i++) {
	arrtemporal[destino.options[i].text] = destino.options[i].value;
	arrdestino[i] = destino.options[i].text;
}

var longitudOrigen = 0;
var longitudDestino = arrdestino.length;
var contador;

for(i = 0; i < origen.options.length; i++) {
	arrtemporal[origen.options[i].text] = origen.options[i].value;
	if (origen.options[i].selected && origen.options[i].value != "") {
		arrdestino[longitudDestino] = origen.options[i].text;
		longitudDestino++;
	} else {
		arrorigen[longitudOrigen] = origen.options[i].text;
		longitudOrigen++;
	}
}
arrorigen.sort();
if (ordenado) {
	arrdestino.sort();
}
origen.length = 0;
destino.length = 0;

for(contador = 0; contador < arrorigen.length; contador++) {
	var no = new Option();
	no.value = arrtemporal[arrorigen[contador]];
	no.text = arrorigen[contador];
	origen[contador] = no;
}
for(contador = 0; contador < arrdestino.length; contador++) {
	var no = new Option();
	no.value = arrtemporal[arrdestino[contador]];
	no.text = arrdestino[contador];
	destino[contador] = no;
   }

//}

}
// ---- fin Proceso para pasar de un selectmultiple a otro --------------
//-----------------------------------------------------------------------
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////


/*  FUNCION CREO QUE SOLO VALIDA LAS VISA
function validarTJ(numero_tarjeta) { // validar el formato de la tarjeta de credito
 var cadena = numero_tarjeta.toString();
 var longitud = cadena.length;
 var cifra = null;
 var cifra_cad=null;
 var suma=0;
 for (var i=0; i < longitud; i+=2){
   cifra = parseInt(cadena.charAt(i))*2;
   if (cifra > 9){ 
     cifra_cad = cifra.toString();
     cifra = parseInt(cifra_cad.charAt(0)) + 
parseInt(cifra_cad.charAt(1));
   }
   suma+=cifra;
 }
 for (var i=1; i < longitud; i+=2){
   suma += parseInt(cadena.charAt(i));
 }
	
 if ((suma % 10) == 0){ 
  alert("Número de tarjeta correcto");
 } else {
  alert("El número de tarjeta no es válido");
 }
}

*/

function imposeMaxLength(Object, MaxLen) //Es MaxLength para textarea
{
  return (Object.value.length <= MaxLen);
}


function abrirVentana(TheURL,TheWidth,TheHeight)
{
	window.open(""+TheURL+"","nuevaventana","width="+TheWidth+",height="+TheHeight+",resizable=yes,scrollbars=yes");
}