function rellenaceros(num)
{
	if (num < 10) num = "0" + num;
	return num;
}

function getFechaHoy()
{
	var mydate=new Date();
	var year=mydate.getYear();
	if (year < 1000)
		year+=1900;
	var day=mydate.getDay();
	var month=mydate.getMonth()+1;
	if (month<10)
		month="0"+month;
	var daym=mydate.getDate();
	if (daym<10)
		daym="0"+daym;
	return daym+"/"+month+"/"+year;

}

function getFechaHoraHoy()
{
	var mydate=new Date();

	var year=mydate.getYear();
	if (year < 1000)
		year+=1900;
	var day   = rellenaceros(mydate.getDay());
	var month = rellenaceros(mydate.getMonth()+1);
	var daym  = rellenaceros(mydate.getDate());

	var Hours = rellenaceros(mydate.getHours());
	var Minutes = rellenaceros(mydate.getMinutes());
	var Seconds = rellenaceros(mydate.getSeconds());
	return daym+"/"+month+"/"+year+" "+Hours+":"+Minutes+":"+Seconds;

}

/////////////////////////////////////////////////////
// VALIDADOR de contenidos de formularios
/////////////////////////////////////////////////////

// Variables generales

var Validador_Global='NO';
var MsgError_Global="";

var Numeros="0123456789";
var LetrasMinus="abcdefghijklmnñopqrstuvwxyzáéíóúü";
var LetrasMayus="ABCDEFGHIJKLMNÑOPQRSTUVWXYZÁÉÍÓÚÜ";

// Funciones base

function VAL_vacio(Valor)
{
        return ((Valor == null) || (Valor.length == 0))
}

function VAL_numero(Valor)
{
//	alert (parseFloat(Valor)+'=='+Valor);
	return (parseFloat(Valor)==Valor)
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Funcion de validacion general
// -----------------------------------------
// Según el tipo, hará una u otra validación
// Tipos y parámetros:
// · VAC : Valor							| P1: Valor
// · NUM : Valor numérico entero			| P1: Valor
// · DEC : Valor numérico decimal			| P1: Valor		P2: Nºdecimales
// · ALF : Valor alfanumérico				| P1: Valor		P2: Caracteres Extras Permitidos	P3: Caracteres Extras Inválidos
// · NEN : Valor numérico entero entre		| P1: Valor		P2: Menor entre						P3: Mayor entre
// · NMA : Valor numérico entero mayor a	| P1: Valor		P2: Mayor a
// · NME : Valor numérico entero menor a	| P1: Valor		P2: Menor a
// · DEN : Valor numérico decimal entre		| P1: Valor		P2: Nºdecimales						P3: Menor entre						P4: Mayor entre
// · DMA : Valor numérico decimal mayor a	| P1: Valor		P2: Nºdecimales						P3: Mayor a
// · DME : Valor numérico decimal menor a	| P1: Valor		P2: Nºdecimales						P3: Menor a
// · EMA : Valor email						| P1: Valor
// · CIF : Valor CIF						| P1: Valor
// · NIF : Valor NIF						| P1: Valor
// · NCB : Valor nº cuenta bancaria			| P1: Valor
// · FECHA : Valor FECHA				 	| P1: Valor	
// · URL   : Valor URL 						| P1: Valor	

function Validador_Contenido(Tipo,oCont,Parametros)
{
	var Valor=oCont.value;
	var Titulo=oCont.Titulo;
	var Tipoelemento=oCont.type;
	var CheckVacio=oCont.Vacio;
	var Resultado=new Array(true,"");
//	alert (Parametros);

	if (CheckVacio=="NO" && VAL_vacio(Valor) ) Resultado=new Array(false,"El campo no puede estar vacío");
	else
	{
		if (!VAL_vacio(Valor) ) // Si puede estar vacio y no lo esta ...
		{
			if (Tipo=="VAC")
			{
				if ( ((Tipoelemento=="select-one") && (Valor=='*' || Valor=='')) || ((Tipoelemento=="select-multiple") && (Valor=='')) )
				{
					Resultado=new Array(false,"Debe seleccionar algun valor");
				}
				else
					Resultado=Validador_Vacio(Valor);
			}
			if (Tipo=="NUM") Resultado=Validador_Numerico(Valor);
			if (Tipo=="DEC") Resultado=Validador_Decimal(Valor,Parametros[0]);
			if (Tipo=="ALF") Resultado=Validador_Alfanumerico(Valor,Parametros[0],Parametros[1],Parametros[2],Parametros[3]);
			if (Tipo=="NEN") Resultado=Validador_Numerico_Entre(Valor,Parametros[0],Parametros[1]);
			if (Tipo=="NMA") Resultado=Validador_Numerico_Mayor(Valor,Parametros[0]);
			if (Tipo=="NME") Resultado=Validador_Numerico_Menor(Valor,Parametros[0]);
			if (Tipo=="DEN") Resultado=Validador_Numerico_Decimal_Entre(Valor,Parametros[0],Parametros[1],Parametros[2]);
			if (Tipo=="DMA") Resultado=Validador_Numerico_Decimal_Mayor(Valor,Parametros[0],Parametros[1]);
			if (Tipo=="DME") Resultado=Validador_Numerico_Decimal_Menor(Valor,Parametros[0],Parametros[1]);
			if (Tipo=="EMA") Resultado=Validador_Email(Valor);
			if (Tipo=="CIF") Resultado=Validador_CIF(Valor);
			if (Tipo=="NIF") Resultado=Validador_NIF(Valor);
			if (Tipo=="CIFNIF") Resultado=Validador_CIFNIF(Valor);
			if (Tipo=="NCB") Resultado=Validador_NCB(Valor);
			if (Tipo=="EXP") Resultado=Validador_Expresion(Valor,Parametros[0],Parametros[1]);
			if (Tipo=="FECHA") Resultado=Validador_Fecha(Valor, Parametros[0]);
			if (Tipo=="URL") Resultado=Validador_Url(Valor);
		}
	}

	if (Validador_Global=="NO")
	{
		if (!Resultado[0])
		{
			oCont.className='campo_entrada_error';
			Validador_Errores(Resultado[1],Titulo);
		}
		else
		{
			oCont.className='campo_entrada';

		}
	}
	else
	{
		if (!Resultado[0])
		{
			oCont.className='campo_entrada_error';
			MsgError_Global+=Titulo+": "+Resultado[1]+"\n";
		}
		else
		{
			oCont.className='campo_entrada';

		}
	}
}

function Validador_Errores(MsgError,Campo)
{
	alert ('Error en '+Campo+':\n\n'+MsgError);
}

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

// Funciones de validaciones

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor si no es vacio
function Validador_Vacio(Valor)
{
	if (VAL_vacio(Valor)) Resultado=new Array(false,"El campo no puede estar vacío");
	
	return new Array(true,"");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor númerico (entero)
function Validador_Numerico(Valor)
{
	if (!VAL_numero(Valor) || Valor.indexOf('.') != -1 ) return new Array(false,"El valor no es numérico entero");
	return new Array(true,"");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor decimal
/* Si se especifica Decimales avisa si contiene demasiados decimales */ 
function Validador_Decimal(Valor,Decimales)
{
	if (!VAL_numero(Valor)) return new Array(false,"El valor no es numérico decimal");
	else if (Decimales>0)
	{	
		Corte=Valor.split(".");
		if (Corte.length==2) if (Corte[1].length>Decimales) return new Array(false,"El número tiene demasiados decimales. Acepta hasta "+Decimales);
	}
	return new Array(true,"");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor alfanumérico (0-9 y aA-zZ)
/* Si se especifica CaracteresValidos entran también en la validación */
/* Si se especifica CaracteresInvalidos se eliminan de la validación */
function Validador_Alfanumerico(Valor,CaracteresValidos,CaracteresInvalidos,NumeroCaracteresMaximo,NumeroCaracteresMinimo)
{
        NumeroCaracteresMaximo=NumeroCaracteresMaximo*1;
        NumeroCaracteresMinimo=NumeroCaracteresMinimo*1;

        if (NumeroCaracteresMaximo !=0)
        {
          if (Valor.length>NumeroCaracteresMaximo)
                      return new Array(false,"No puede tener mas de "+NumeroCaracteresMaximo+" caracteres");
        }

        if (NumeroCaracteresMinimo !=0)
        {
          if (Valor.length<NumeroCaracteresMinimo)
                      return new Array(false,"No puede tener menos de "+NumeroCaracteresMinimo+" caracteres");
        }

	CaracterValido=Numeros+LetrasMinus+LetrasMayus;
	if (CaracteresValidos!='') CaracterValido+=CaracteresValidos;
	if (CaracteresInvalidos!='')
	{
		for (a=0; a<CaracteresInvalidos.length; a++)
		{
			Corte=CaracterValido.split(CaracteresInvalidos.charAt(a));
			if (Corte.length==2) CaracterValido=Corte[0]+Corte[1];
		}
	}
	CaracteresError='';
	for (a=0; a<Valor.length; a++) if (CaracterValido.split(Valor.charAt(a)).length!=2) CaracteresError+=Valor.charAt(a);
	if (CaracteresError!='') return new Array(false,"Caracteres Inválidos: "+CaracteresError);
	return new Array(true,"");
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor numerico entre dos valores incluidos (enteros)
function Validador_Numerico_Entre(Valor,Menor,Mayor)
{
	if (!VAL_numero(Valor) || Valor.indexOf('.') != -1 ) return new Array(false,"El valor no es numérico entero");
	Valor=Valor*1;
	Menor=Menor*1;
	Mayor=Mayor*1;
	if ( (Valor<Menor) || (Valor>Mayor)) return new Array(false,"El valor debe estar entre "+Menor+" y "+Mayor);
	return new Array(true,"");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor numerico mayor a (enteros)
function Validador_Numerico_Mayor(Valor,Mayor)
{
	if (!VAL_numero(Valor) || Valor.indexOf('.') != -1 ) return new Array(false,"El valor no es numérico entero");
        Valor=Valor*1;
        Mayor=Mayor*1;

	if (Valor<=Mayor) return new Array(false,"El valor debe ser mayor a "+Mayor);
	return new Array(true,"");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor numerico menor a (enteros)
function Validador_Numerico_Menor(Valor,Menor)
{
	if (!VAL_numero(Valor) || Valor.indexOf('.') != -1 ) return new Array(false,"El valor no es numérico entero");
        Valor=Valor*1;
        Menor=Menor*1;
	if (Valor>=Menor) return new Array(false,"El valor debe ser menor a "+Menor);
	return new Array(true,"");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor numerico entre dos valores incluidos (decimal)
function Validador_Numerico_Decimal_Entre(Valor,Decimales,Menor,Mayor)
{
	if (!VAL_numero(Valor)) return new Array(false,"El valor no es numérico decimal");
	else if (Decimales>0)
	{
		Corte=Valor.split(".");
		if (Corte.length==2) if (Corte[1].length>Decimales) return new Array(false,"El número tiene demasiados decimales. Acepta hasta "+Decimales);
	}

	Valor=Valor*1;
	Menor=Menor*1;
	Mayor=Mayor*1;
	if (Valor<Menor || Valor>Mayor) return new Array(false,"El valor debe estar entre "+Menor+" y "+Mayor);
	return new Array(true,"");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor numerico mayor a (decimal)
function Validador_Numerico_Decimal_Mayor(Valor,Decimales,Mayor)
{
	if (!VAL_numero(Valor)) return new Array(false,"El valor no es numérico decimal");
	else if (Decimales>0)
	{	
		Corte=Valor.split(".");
		if (Corte.length==2) if (Corte[1].length>Decimales) return new Array(false,"El número tiene demasiados decimales. Acepta hasta "+Decimales);
	}

        Valor=Valor*1;
        Mayor=Mayor*1;
	if (Valor<=Mayor) return new Array(false,"El valor debe ser mayor a "+Mayor);
	return new Array(true,"");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor numerico menor a (decimal)
function Validador_Numerico_Decimal_Menor(Valor,Decimales,Menor)
{
	if (!VAL_numero(Valor)) return new Array(false,"El valor no es numérico decimal");
	else if (Decimales>0)
	{	
		Corte=Valor.split(".");
		if (Corte.length==2) if (Corte[1].length>Decimales) return new Array(false,"El número tiene demasiados decimales. Acepta hasta "+Decimales);
	}
        Valor=Valor*1;
        Menor=Menor*1;
	if (Valor>=Menor) return new Array(false,"El valor debe ser menor a "+Menor);
	return new Array(true,"");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor email
function Validador_Email(Valor)
{
	Resultado=Validador_Alfanumerico(Valor,"@._-","");
	if (Resultado[0])
	{
		Corte=Valor.split("@");
		if (Corte.length==1) return new Array(false,"E-mail incorrecto (@)");
		else if (Corte[1].split(".").length==1) return new Array(false,"E-mail incorrecto (.dominio)");
	}
	else return Resultado;
	return new Array(true,"");
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor Url
function Validador_Url(Valor) {
	var regexp = /(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/
	if (regexp.test(Valor) ) 
	   return new Array(true,"");
	else
	   return new Array(false,"No es una URL correcta.");	
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor CIF
function Validador_CIF(Valor)
{
	var pares = 0;
	var impares = 0;
	var suma;
	var ultima;
	var unumero;
	var uletra = new Array("J", "A", "B", "C", "D", "E", "F", "G", "H", "I");
	var xxx;
    var regular =/^[ABCDEFGHKLMNPQS]\d\d\d\d\d\d\d[0-9,A-J]$/g;

	texto = Valor.toUpperCase();
        if (Valor.length<9)
	  {
             return new Array(false,"El CIF debe tener 9 caracteres (1 Letra,7 Dígitos,1 Dígito o 1 Letra)");
	  }

        else
          {
           var cif1=Valor.substr(0,1);
           if (!(/^[ABCDEFGHKLMNPQS]{1}/).test(cif1))
            {
              return new Array(false,"El primer caracter debe ser una letra de las siguientes: A,B,C,D,E,F,G,H,K,L,M,N,P,Q,S.");
            }
           else
           {
             cif2=Valor.substr(1,7);
             if ( ! (/^[0123456789]{7}/).test(cif2))
               {
                 return new Array(false,"Existen letras donde solo deberían aparecer números.");
               }
             else
               {
               	 letra_orig =Valor.substr(8,1);
               	 if ( !(/^[A-Z0-9]/).test(letra_orig))
  		    {
		     return new Array(false,"El ultimo caracter ha de ser una letra Mayúscula o un Número.");
		    }
		 else
		    {
		    	
				var v1 = new Array(0,2,4,6,8,1,3,5,7,9); 
				var temp = 0; 
				var temp1;
				
				  
				for( i = 2; i <= 6; i += 2 ) 
				{
					temp = temp + v1[ parseInt(Valor.substr(i-1,1)) ];
					temp = temp + parseInt(Valor.substr(i,1));
				};
				
				temp = temp + v1[ parseInt(Valor.substr(7,1)) ];
				
				temp = (10 - ( temp % 10));
				
				if( temp == 10 )
					temp = 0;
				
				unumero = parseInt(temp);
				
				if ((letra_orig == unumero) || (letra_orig == uletra[unumero]))
		        	return new Array(true,"");
	            else
		        	return new Array(false,"El último carácter debería ser "+unumero+" o "+uletra[unumero]);


				
				/*
				for (var cont = 1 ; cont < 7 ; cont ++)
                         {
		            xxx = (2 * parseInt(texto.substr(cont++,1))).toString() + 0;
		            impares += parseInt(xxx.substr(0,1)) + parseInt(xxx.substr(1,1));
		            pares += parseInt(texto.substr(cont,1));
	                 }
	                 xxx = (2 * parseInt(texto.substr(cont,1))).toString();
	                 impares += parseInt(xxx.substr(0,1)) + parseInt(0 + xxx.substr(1,1));

	                 suma = (pares + impares).toString();
	                 unumero = parseInt(suma.substr(suma.length - 1, 1));
	                 if (unumero==0)
	                 	unumero=10;
	                 	
	                 unumero = (10 - unumero).toString();

                     if ((letra_orig == unumero) || (letra_orig == uletra[unumero]))
		              return new Array(true,"");
	                 else
		              return new Array(false,"El último carácter debería ser "+unumero+" o "+uletra[unumero]);
				*/


		    }

               }
           }
          }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor NIF
function Validador_NIF(Valor)
{
	var letras = 'TRWAGMYFPDXBNJZSQVHLCKE';	
	
	if (Valor.length<9)
	  {
		// Comprobamos la longitud total  
	    return new Array(false,"Debe tener 9 caracteres, complete con ceros a la izquierda si fuera necesario.");
      }
	else
		{
		  // Comprobamos que empiece por una X (Extranjeros) o por un número
		  nif1=Valor.substr(0,1);
			
		    if (!(/^[X0123456789]{1}/).test(nif1))
		      {
				return new Array(false,"El primer caracter debe ser una X o un número.");
			  }	
			else
				{
				if (nif1=='X')
				   {
					nif2=Valor.substr(1,7);
					expresion=/^[0123456789]{7}/;
				}
				else
				   { 
					nif2=Valor.substr(0,8);
					expresion=/^[0123456789]{8}/;
				}
				if ( !(expresion).test(nif2) ) 
					{
					return new Array(false,"Existen letras donde solo deberian aparecer números.");
				}
			    else
				{
				 letra_orig =Valor.substring(8,9);	
				 if ( !(/^[A-Z]/).test(letra_orig))
					{
					 return new Array(false,"El ultimo caracter ha de ser una letra Mayúscula.");
					}	
				 else
				    {
					 numero = nif2%23;	
					 letra_calculada = letras.substring(numero, numero+1);
					 if (letra_orig != letra_calculada)
						{
							return new Array(false,"La letra no es válida, deberia ser "+letra_calculada+" .");
						}
					 else
						{
						 return new Array(true,"");	
						}
				    }
				}	
			}
		}	
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un CIF o un NIF
function Validador_CIFNIF(Valor)
{
	temp=Valor.toUpperCase(); // pasar a mayúsculas

	if ((/^[A-Z]{1}/).test(temp) && !(/^[X]{1}/).test(temp)) //Si empieza por una letra que no sea X de un CIF lo validamos como tal
    	return Validador_CIF(Valor);
	else                                       //Sino debe tratarse de un NIF
    	return Validador_NIF(Valor);
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un valor Número de Cuenta Bancaria
function Validador_NCB(Valor)
{
	if (Valor.length!=20) return new Array(false,"El número de cuenta no es correcto. Use 20 dígitos");
	if (!VAL_numero(Valor)) return new Array(false,"El número de cuenta no es correcto. Use solo dígitos");
	return new Array(true,"");
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida una Fecha
function esDigito(sChr)
{
	var sCod = sChr.charCodeAt(0);
	return ((sCod > 47) && (sCod < 58));
}

function valSep(Valor)
{
	var bOk = false;
	bOk = bOk || ((Valor.charAt(2) == "-") && (Valor.charAt(5) == "-"));
	bOk = bOk || ((Valor.charAt(2) == "/") && (Valor.charAt(5) == "/"));
	return bOk;
}

function finMes(Valor){
	var nMes = parseInt(Valor.substr(3, 2), 10);
	var nRes = 0;
	switch (nMes){
		case 1: nRes = 31; break;
		case 2: nRes = 29; break;
		case 3: nRes = 31; break;
		case 4: nRes = 30; break;
		case 5: nRes = 31; break;
		case 6: nRes = 30; break;
		case 7: nRes = 31; break;
		case 8: nRes = 31; break;
		case 9: nRes = 30; break;
		case 10: nRes = 31; break;
		case 11: nRes = 30; break;
		case 12: nRes = 31; break;
	}
	return nRes;
}

function valDia(Valor)
{
	var bOk = false;
	var nDia = parseInt(Valor.substr(0, 2), 10);
	bOk = bOk || ((nDia >= 1) && (nDia <= finMes(Valor)));
	return bOk;
}

function valMes(Valor)
{
	var bOk = false;
	var nMes = parseInt(Valor.substr(3, 2), 10);
	bOk = bOk || ((nMes >= 1) && (nMes <= 12));
	return bOk;
}

function valAno(Valor)
{
	var bOk = true;
	var nAno = Valor.substr(6);
	bOk = bOk && ((nAno.length == 2) || (nAno.length == 4));
	if (bOk)
	{
		for (var i = 0; i < nAno.length; i++)
		{
			bOk = bOk && esDigito(nAno.charAt(i));
		}
	}
	return bOk;
}

function Validador_Fecha(Valor, Campo)
{
	var bOk = true;
	var mensaje="La fecha introducida NO es correcta";
	if (Valor.length > 0)
	{
		// Si el dia viene con un solo digito lo ponemos con dos
		if ( (Valor.indexOf('/') == 1) || (Valor.indexOf('-') == 1) )
		{
			Valor='0'+Valor.substr(0,10);
		}
		
		// Si el mes viene con un solo digito lo ponemos con dos
		resto=Valor.substr(3,12);
		if ( (resto.indexOf('/') == 1) || (resto.indexOf('-') == 1) )
		{
			Valor=Valor.substr(0,3)+'0'+resto;
		}
		
		// Si el año viene con dos digitos lo ponemos con cuatro
		resto=Valor.substr(6,4);
		if ( (resto.length == 2) )
		{
			var valor=parseInt(resto);
			if ( ( !isNaN(valor) ) && ( valor > 30 ) )
			{
				Valor=Valor.substr(0,6)+'19'+resto;
			}
			else if ( !isNaN(valor) )
			{
				Valor=Valor.substr(0,6)+'20'+resto;
			}
		}
		
		bOk = bOk && (valAno(Valor));
		bOk = bOk && (valMes(Valor));
		bOk = bOk && (valDia(Valor));
		
		// Vemos los separadores
		bOk = bOk && (valSep(Valor));
		
		if ( bOk || ((Valor.charAt(2) == "-") && (Valor.charAt(5) == "-")) )
		{
			Valor=Valor.substr(0,2)+"/"+Valor.substr(3,2)+"/"+Valor.substr(6,4);
		}

		dia=Valor.substr(0,2); 
		mes=Valor.substr(3,2); 
		ano=Valor.substr(6,4); 
		// Vemos si ha metido fecha bisiesta
		// Año no bisiesto y es febrero y el dia es mayor a 28 
		if ( (ano%4 != 0) && (mes == 02) && (dia == 29) ) 
		{ 
			bOk=false;
			mensaje="El año introducido NO es Bisiesto";
		} 

		if (!bOk)
		{
			return new Array(false,mensaje);
		}
		else
		{
			document.getElementById(Campo).value=Valor;
			return new Array(true,"");
		}
	}

return new Array(true,"");
	
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida una expresion regular dada
function Validador_Expresion(Valor,Expresion,Mensaje)
{

 var patron = new RegExp(Expresion);
 if (patron.test(Valor))
    return new Array(true,"");
 else
    return new Array(false,Mensaje);
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Valida un formulario dado
function Validar_Formulario(Formulario)
{
	Elementos=Formulario.length;
	Validador_Global="SI";
	MsgError_Global="";
	for (TraceElementos=0; TraceElementos<Elementos; TraceElementos++)
	{
		oElementForm=Formulario[TraceElementos];
		if (oElementForm.ValForm!='')
		{
			if (eval('oElementForm.'+oElementForm.ValForm)!=null) eval('oElementForm.'+oElementForm.ValForm+'()');
		}
	}
	if (MsgError_Global!="")
	 {
           Validador_Errores(MsgError_Global,"el formulario");
           Validador_Global="NO";
           MsgError_Global="";
           return false;

         }
        else
        {
         Validador_Global="NO";
 	 MsgError_Global="";
         return true;
        }

}