/*======================================================================================
Entrega la Posición de un determinado caracter dentro de un string
InString: String a evaluar.
Char : Caracter a encontrar.
*/
function PosChar(InString, Char)
{
	Char = Char.toLowerCase();
	for ( pos=0; pos < InString.length ; pos++){
		if ( InString.charAt(pos).toLowerCase() == Char ) {
			return pos++;
		}
	}
	return 0;		
}
/*======================================================================================
Entrega la cantidad de caracteres de la izquierda de un string
InString: String a evaluar.
cantidad: Numero de caracteres desde la izquierda
*/
function left(InString, cantidad)
{
	if (cantidad > InString.length){
		return InString
	}
	InString = InString.substring(0, cantidad);
	return InString
}
/*======================================================================================
Entrega la cantidad de caracteres de la derecha de un string
InString: String a evaluar.
cantidad: Numero de caracteres desde la derecha
*/
function right(Obj, cantidad)
{
	if (cantidad > InString.length){
		return InString
	}
	InString = InString.substring(InString.length - cantidad, InString.length);
	return InString
}


/*======================================================================================
Entrega el índice del elemento seleccionado en un Objeto Select
con parámetro principal como Objeto	
Obj: Objeto a analizar
Retorna : numero del objeto seleccionado
*/
function Obj_Selec(Obj) {
	var numero=-1
	for (var i=0; i < Obj.length; i++) {
		if (Obj.options[i].selected)
			numero = i
	}
	return numero
}

/*======================================================================================
Entrega el índice del elemento chequeado en un Objeto Radio
con parámetro principal como Objeto	
Obj: Objeto a analizar
Retorna : numero del objeto seleccionado
*/
function Obj_Check(Obj) {
	var numero=-1
	for (var i=0; i < Obj.length; i++) {
		if (Obj[i].checked)
			numero = i
	}
	return numero
}


/*======================================================================================
Función que se encarga de hacer un arreglo
numero: Largo que tendra el arreglo. 
Retorna un Objeto
*/

function hacerArreglo(numero) {
	this.length = numero;
	for (var i = 0; i < numero; i++)
		this[i] = 0;
	return this;
}

/*======================================================================================
Funcion que elimina los blancos a la izquierda de un string.
Obj: Objeto que contiene Strin a eliminar blancos de la izquierda.
Retorna :Un Objeto
*/
function ltrim(obj) {
	InString = obj.value;
	n = i = 0;
	while (i < InString.length) {
		if (InString.charAt(i) != " ") {
			n = i
			break
		}
		i++
	}
	if (n == 0 && i == InString.length)
		obj.value = ''
	else
		obj.value = InString.substring(n, InString.length)
	return obj;
}

/*======================================================================================
Elimina los blancos a la derecha de un string.
obj:	objeto que contiene string a eliminar blancos de la derecha
Retorna: Un Objeto	
*/
function rtrim(obj) {
	InString = obj.value;
	n = i = InString.length
	while (i > 0) {
		if (InString.charAt(i - 1) != " ") {
			n = i
			break
		}
		i--
	}
	if (n == InString.length && i == 0)
		obj.value = ''
	else
		obj.value = InString.substring(0, n);
	return obj;
}

/*======================================================================================
Elimina los blancos de los extremos de un string.
Obj:	objeto que contiene string a eliminar blancos de los extremos
Retorna: Un Objeto	
*/

function trim(Obj) {
	return rtrim(ltrim(Obj));
}

/*======================================================================================
Verifica blancos al interior de un string.
obj:	objeto que contiene string para determinar si tiene
blancos en su interior
Retorna: Un Booleano	
*/
function tieneBlancos(Obj) {
	InString = Obj.value;
	n = i = 0;
	while (i < InString.length) {
		if (InString.charAt(i) == " ") {
			return true;
		}
		i++;
	}
	return false;
}

/*======================================================================================
Función que reemplaza en un string un detrminado 
patron por otro. 
Ej: reemplazaString("Hola Juanito","Juanito","Hernán")
	Salida es : Hola Hernán
	reemplazaString("Hola Juanito","x","")
	Salida es : Hola Juanito
	reemplazaString("Hola Juanito","o","nada")
	Salida es : Hnadala Juanitnada
Retorna : Un String
*/
function reemplazaString(InString,encontrar,remplaza){
    pos=0;
    while(pos >= 0){
		pos=InString.indexOf(encontrar);
		if(pos < 0) return InString;
		Strinicio=InString.substring(0,pos);
		Strfin=InString.substring(pos + encontrar.length,InString.length);
		InString=Strinicio + remplaza + Strfin;
    }
}

/*======================================================================================
Funcion que invierte el orden de un string.
InString:	String a invertir caracteres
Retorna un String	
*/
function strReverse(InString) {
	var rever = ""
	for (var i = InString.length - 1; i >= 0; i--)
		rever += InString.charAt(i);
	return rever;
}

/*======================================================================================

*/
function TodasMayusculas(Obj){
	Obj = trim(Obj);
	if (Obj.value != ''){
		Obj.value = Obj.value.toUpperCase();
	}
	return Obj;
}
/*======================================================================================

*/
function TodasMinusculas(Obj){
	Obj = trim(Obj);
	if (Obj.value != ''){
		Obj.value = Obj.value.toLowerCase();
	}
	return Obj;
}
/*======================================================================================

*/
function PrimeraMayuscula(Obj){
	Obj = trim(Obj);
	InString = Obj.value;
	if (InString != ''){
		Primera = InString.charAt(0);
		Primera = Primera.toUpperCase();
		if (InString.length > 1){
			InString = Primera + InString.substring(1,InString.length);
		}
		else {
			InString = Primera;
		}
	}
	Obj.value = InString;
	return 
}

/*======================================================================================
*/
function InicialesMayusculas(Obj){
	Obj = trim(Obj);
	InString = Obj.value;
	if (InString != ''){
		Amay = InString.charAt(0);
		Amay = Amay.toUpperCase();
		InString = Amay + InString.substring(1,InString.length);
		for (i=1; i < InString.length;i++){
			if (InString.charAt(i) == ' '){
				Amay = InString.charAt(i+1);
				Amay = Amay.toUpperCase();
				InString = InString.substring(0,i+1) + Amay + InString.substring(i+2,InString.length);
			}	
		}
	}
	Obj.value = InString;
	return 
}




/*======================================================================================
Función que verifica que la entrada sea de un determinado tipo de dato
InStrin :	String a evaluar- Numerico con decimales
Retorna : Un Booleano
*/
function SoloNumDec(InString)
{
	Char = InString.charAt(0);
    if(!esNumerico(Char))
 	   return false;

		for (Cont=1; Cont < InString.length; Cont++) 
		   {
    		Char = InString.charAt(Cont);
             	if(!esNumerico(Char))
		    	 RefString=",";
            	if (RefString.indexOf(Char, 0) == -1) 
			    return false;
    		
       	  }
    	return true;
 }


/*======================================================================================
Función que verifica que la entrada sea de un determinado tipo de dato
InStrin :	String a evaluar
tipo	:	9 - Numerico 
			A - Alfabetico
			X - AlfaNumerico
Retorna : Un Booleano
*/
function SoloTipo(InString, tipo){
		for (Cont=0; Cont < InString.length; Cont++) {
    		Char = InString.charAt(Cont);
    		if (tipo == '9') {
    			if(!esNumerico(Char))
    				return false;
    		}
    		else if (tipo == 'A') {
    			if(!esAlfabetico(Char))
    				return false;
    		}
    		else if (tipo == 'X') {
    			if(!esAlfaNumerico(Char))
    				return false;
    		}
    		else if (tipo == 'H') {
    			if(!esHexa(Char))
    				return false;
    		}
		}
  	return true;
 }

/*======================================================================================
Funcion que solo permite el ingreso de datos en un determinado formato
InString	:	String a evaluar.
Mask		:	Formato que debe poseer el String a evaluar
				Ej: '99/99/9999' marcara para una fecha
				'9' - Numero
				'A' - Alfabetico
				'X' - AlfaNumerico
Retorna : Un Booleano
*/

function Mascara(InString, Mask) {
    	LenStr = InString.length;
    	LenMsk = Mask.length;
    	if ((LenStr==0) || (LenMsk==0))
    		return false;
    	if (LenStr != LenMsk)
    		return false;
    	TempString=""
    	for (Cont=0; Cont < InString.length; Cont++) {
    		StrChar = InString.charAt(Cont);
    		MskChar = Mask.charAt(Cont);
    		if (MskChar == '9') {
    			if(!esNumerico(StrChar))
    				return false;
    		}
    		else if (MskChar == 'A') {
    			if(!esAlfabetico(StrChar))
    				return false;
    		}
    		else if (MskChar == 'X') {
    			if(!esAlfaNumerico(StrChar))
    				return false;
    		}
    		else {
    			if (MskChar != StrChar) // compara otros caracteres
    				return false;		// ej: los / de la fecha
    		}
    	}
    	return true;
}
    
/*======================================================================================
Funcion que verifica si un caracter es Alfabetico (Acepta blancos)
Char	:	Caracter a evaluar.
Oservación: Si se necesita que esta funcion acepte otro caracter 
agregarlo al String de Referencia (RefString)
Retorna : Un Booleano
*/
    
function esAlfabetico(Char) {
    	if(Char.length!=1) 
    		return false;
    	Char=Char.toLowerCase();
    	RefString='abcdefghijklmnñopqrstuvwxyz áéíóúü';
    	if (RefString.indexOf (Char.toLowerCase(), 0) == -1) 
    		return false;
    	return true;
}
/*======================================================================================    
Funcion que verifica si un caracter es AlfaNumerico (Acepta Blancos)
Char	:	Caracter a evaluar.
Retorna : Un Booleano
*/
function esAlfaNumerico(Char) {
    	if(Char.length != 1) 
    		return false;
    	Char=Char.toLowerCase();
    	RefString='1234567890abcdefghijklmnñopqrstuvwxyz áéíóú';
    	if (RefString.indexOf(Char,0) == -1) 
    		return false;
    	return true;
}

/*======================================================================================    
Funcion que verifica si un caracter es Numerico
Char	:	Caracter a evaluar.
Retorna : Un Booleano
*/
function esNumerico(Char) {
    	if(Char.length!=1) 
    		return false;
    	RefString="1234567890";
    	if (RefString.indexOf(Char, 0) == -1) 
    		return false;
    	return true;
}






/*======================================================================================    
Funcion que verifica si un caracter pertenece al rango de Hexadecimal
Char	:	Caracter a evaluar.
Retorna : Un Booleano
*/
function esHexa(Char) {
    	if(Char.length!=1) 
    		return false;
    	Char=Char.toLowerCase();
    	RefString="1234567890abcdef";
    	if (RefString.indexOf(Char, 0) == -1) 
    		return false;
    	return true;
}


/*======================================================================================
Verifica si un Run es válido como número.
Devuelve nulo	
Obj:	objeto que contiene el numero de rut a evaluar
*/
	
function Ver_Run(Obj) {

	if (!SoloTipo(Obj.value,'9')) {
		alert('Rut incorrecto');
		Obj.value="";
		Obj.focus();
	} else {
		Obj.value=parseInt(Obj.value);
	}
}

/*======================================================================================
Verifica si un Dígito Verificador es válido como número y K.
Obj:	objeto que contiene el digito verificador del rut a evaluar
Devuelve nulo	
*/
function Ver_DV(Obj) {
	if (!SoloTipo(Obj.value,'9')&& Obj.value.toLowerCase()!='k'){
		alert("Dígito Verificador Inválido.");
		Obj.value="";
		Obj.focus();
	}
}



function ChequearRutDigito2(ObjRut, ObjDigito) {
	var dvr = '0'
	suma = 0
	mult = 2
	strObjRut = ObjRut;
	strObjDig = ObjDigito;

	for ( i = strObjRut.length - 1 ; i >= 0 ; i -- ) {
		suma = suma + strObjRut.charAt(i) * mult;
		if ( mult == 7 )
			mult = 2;
		else
			mult ++;
	}
	res = suma % 11;
	if ( res == 1 )
		dvr = 'k';
	else {
		if ( res == 0 )
			dvr = '0';
		else {
			dvi = 11 - res;
			dvr = dvi + "";
		}
	}


	if ( dvr != strObjDig.toLowerCase() )
		return false;
	return true;
}


/*======================================================================================
Verifica si un Rut con su Dígito Verificador es válido.
Devuelve booleano	
*/

function ChequearRutDigito(ObjRut, ObjDigito) {
	var dvr = '0'
	suma = 0
	mult = 2
	strObjRut = ObjRut.value;
	strObjDig = ObjDigito.value;
	for ( i = strObjRut.length - 1 ; i >= 0 ; i -- ) {
		suma = suma + strObjRut.charAt(i) * mult;
		if ( mult == 7 )
			mult = 2;
		else
			mult ++;
	}
	res = suma % 11;
	if ( res == 1 )
		dvr = 'k';
	else {
		if ( res == 0 )
			dvr = '0';
		else {
			dvi = 11 - res;
			dvr = dvi + "";
		}
	}


	if ( dvr != strObjDig.toLowerCase() )
		return false;
	return true;
}


/*======================================================================================
Devuelve Dígito Verificador de un rut .
======================================================================================*/

function DevuelveDigito(ObjRut) {
	var dvr = '0'
	suma = 0
	mult = 2

	strObjRut = ObjRut.value;
	for ( i = strObjRut.length - 1 ; i >= 0 ; i -- ) 
		{
			suma = suma + strObjRut.charAt(i) * mult;
			if ( mult == 7 )
				mult = 2;
			else
				mult ++;
		}
		res = suma % 11;
		if ( res == 1 )
			dvr = 'k';
		else 
			{
			if ( res == 0 )
				dvr = '0';
			else 
				{
					dvi = 11 - res;
					dvr = dvi + "";
				}
			}
		return dvr;

}


/*======================================================================================
Verifica si un Rut con su Dígito Verificador es válido.
Formato de Entrada 99.999.999-X
Devuelve booleano	
*/

function ValidaRutFormateado(ObjRut) {
	var dvr = '0'
	suma = 0
	mult = 2

	strRut = ObjRut.value
	if (strRut.length<0 && strRut.length>12)
		return false;
	strObjRut = strRut.substring(0, strRut.length-2);
	strObjDig = strRut.substring(strRut.length-1);
	for ( i = strObjRut.length - 1 ; i >= 0 ; i -- ) {
		if (strObjRut.charAt(i)!='.' && strObjRut.charAt(i)!='-'){
			suma = suma + strObjRut.charAt(i) * mult;
			if ( mult == 7 )
				mult = 2;
			else
				mult ++;
		}
	}
	res = suma % 11;
	if ( res == 1 )
		dvr = 'k';
	else {
		if ( res == 0 )
			dvr = '0';
		else {
			dvi = 11 - res;
			dvr = dvi + "";
		}
	}
	if ( dvr != strObjDig.toLowerCase() )
		return false;
	return true;
}






/*======================================================================================    
Funcion que verifica si una fecha es valida
InString: String a evaluar
Formato:	dma (dia mes ano)
			mda (mes dia ano)
			amd (ano mes dia)
Observación: es utilizada por la funcion Ver_Fecha(Obj) (Siguiente)
Retorna : Un Booleano
*/
function EsFecha(InString,formato) {
	var anyo
		if (formato == "dma"){
			dia=InString.substring(0,2);
			mes=InString.substring(3,5);
			anyo=InString.substring(6,10);

		}
		if (formato == "mda"){
			mes=InString.substring(0,2);
			dia=InString.substring(3,5);
			anyo=InString.substring(6,10);
		}
		if (formato == "amd"){
			anyo=InString.substring(0,4);
			mes=InString.substring(5,7);
			dia=InString.substring(8,10);
		}
		if (dia == '08') dia = '8';	// parseInt("08") == 10		base octogonal
		if (dia == '09') dia = '9';	// parseInt("09") == 11		base octogonal
		if (mes == '08') mes = '8';	// parseInt("08") == 10		base octogonal
		if (mes == '09') mes = '9'; // parseInt("09") == 11		base octogonal
		dia=parseInt(dia);
		mes=parseInt(mes);
		anyo=parseInt(anyo);
  if (InString.substring(6,10).length< 4) anyo='20' + InString.substring(6,10)
	if (anyo < 1900) return false;    // Anyo mayor a 1900 (por la Base de Datos)
		mes = mes - 1;  // El mes se representa del 0 al 11 (solo para la validación)
		esfecha = new Date(anyo,mes,dia);
		if (dia == esfecha.getDate()){
			if(mes == esfecha.getMonth()){
				if(anyo == esfecha.getFullYear()){
					return true;
				}
			}
		}
		return false;
}




/*======================================================================================    
Funcion que valida una fecha con un detrminado formato
Obj	:	Objeto que contiene la fecha a evaluar
Observaciones	:	Esta funcion llama mascara para 
validar un cierto formato de entrada (esta mascara 
puede ser cambiada) por ej: 99-99-9999 
Retorna : Un Booleano
*/
function VerFecha(Obj){
		if(!Mascara(Obj.value,'99/99/9999')){
			alert('Formato de fecha es dd/mm/aaaa');
			/*Obj.value='';
			Obj.focus();*/
			return false;
		}
		else if (!EsFecha(Obj.value,'dma')){
			/*alert('Fecha Invalida');
			Obj.value='';
			Obj.focus();*/
			return false;
		}
		return true;
}

/*======================================================================================
Funcion que verifica si un numero es entero.
InString	: String a evaluar.
Signo		: '+' Solo Positivos
			  '-' Solo Negativos
			  ' ' Acepta positivos y negativos 
Retorna : Un Booleano
*/
function esEntero(InString, Signo){
		i=0;
		c=InString.charAt(i);   // Saca el signo 
		if (c == '-') {			
			if (Signo == '+') return false;
			InString=InString.substring(i+1, InString.length)
		} 
		else if (c == '+'){
			if (Signo == '-') return false;
			InString=InString.substring(i+1, InString.length)
		}
		else if (c >= '0' && c <= '9') {   // Si no trae asume que es positivo
				if (Signo == '-') return false
		}
		if (!SoloTipo(InString,'9'))  //valida que sean solo numeros
			return false;
		return true;
}

/*======================================================================================
Funcion que permite que solo se ingresen numeros enteros
Obj	:	Objeto que posee el string a evaluar
Observacion : Ver funcion esEntero() para el signo
Retorna : Un Booleano
*/		 
function NumeroEntero(Obj){
		if (!esEntero(Obj.value,' ')|| Obj.value==''){ 
			return false;
		}
		return true;
}

   
/*======================================================================================   
Funcion que verifica si un numero es real.
InString	: String a evaluar.
Signo		: '+' Solo Positivos
			  '-' Solo Negativos
			  ' ' Acepta positivos y negativos 
Retorna : Un Booleano
*/
function esReal(InString, Signo){
		i=0;
		c=InString.charAt(i);   // Saca el signo 
		if (c == '-') {			
			if (Signo == '+') return false;
			InString=InString.substring(i+1, InString.length)
		} 
		else if (c == '+'){
			if (Signo == '-') return false;
			InString=InString.substring(i+1, InString.length)
		}
		else if (c >= '0' && c <= '9') {   // Si no trae asume que es positivo
				if (Signo == '-') return false
		}
		puntos=posicion=0;
		for (cont=0; cont < InString.length; cont++) { 
			if (InString.charAt(cont) == '.') {
				puntos = puntos + 1;
				posicion = cont;
			}
		}
		
		if (puntos > 1) return false;
		if (puntos == 1 && InString.length == 1) return false;
		if (InString.length > 1){ 
			if (posicion+1 == InString.length) return false;
		}
		InString = reemplazaString(InString,'.','');  //Saca el punto 
		if (!SoloTipo(InString,'9'))  //valida que sean solo numeros
			return false;
		return true;
}
    
    
/*======================================================================================
Funcion que permite que solo se ingresen numeros reales
Obj	:	Objeto que posee el string a evaluar
Observacion : Ver funcion esReal para el signo
Retorna : Un Booleano
*/		 
function NumeroReal(Obj){
		if (!esReal(Obj.value,' ')){ 
			alert('Ingrese solo Numeros reales');
			Obj.value='';
			Obj.focus();
			return false;
		}
		return true;
}

/*======================================================================================
Funcion que valida numeros Hexadecimales
InString	:	String a evaluar
Retorna : Un Booleano
*/
function esHexadecimal(InString){
	if (!SoloTipo(InString,'H'))
		return false;
	return true;

}
	
/*======================================================================================
Funcion que permite que solo se ingresen numeros Hexadecimales
Obj	:	Objeto que posee el string a evaluar
Observacion : Ver funcion esReal para el signo
Retorna : Un Booleano

*/
function NumeroHexa(Obj){
		if (!esHexadecimal(Obj.value)){ 
			alert('Ingrese solo Numeros Hexadecimales');
			Obj.value='';
			Obj.focus();
			return false;
		}
		return true;
}

/*======================================================================================
Convierte un Número entero decimal en hexadecimal.
Obj:	Objeto que contiene el numero decimal
Retorna:	String	
*/
function dechex(Obj) {
	var resto = 0;
	var strrever = "";
	
	for (var numstr = Obj.value; numstr > 0; numstr /= 16) {
		resto = numstr % 16;
		if (resto < 10) 
			strrever += resto;
		else { if (resto == 10) 
			strrever += "A";
		else { if (resto == 11) 
			strrever += "B";
		else { if (resto == 12) 
			strrever += "C";
		else { if (resto == 13) 
			strrever += "D";
		else { if (resto == 14) 
			strrever += "E";
		else { if (resto == 15) 
			strrever += "F";
		} } } } } }
		numstr -= resto;
	}
	return strReverse(strrever);
}

/*======================================================================================
Funcion que valida que un numero posea 7 ó 6 numeros
obligatorios, para el caso de un telefono de la region metropolitana
o de otra region.
Obj: Objeto que posee el string a evaluar.
Retorna : Un Booleano
*/
function esTelefono(Obj){
		if(Mascara(Obj.value,'9999999')) return true; // RM
		else if(Mascara(Obj.value,'999999')) return true; //Otras regiones
		else if(Mascara(Obj.value,'99999999')) return true; //Celulares
		else {
				alert('Ingrese Numero de Telefono Válido');
				Obj.value='';
				Obj.focus();
				return false;
		}
}

/*======================================================================================
Funcion que valida que un numero posea 7 ó 6 numeros
obligatorios, para el caso de un telefono de la region metropolitana
o de otra region.  Se incluye validación con código de area
Obj: Objeto que posee el string a evaluar.
Retorna : Un Booleano
*/
function esTelefonoArea(Obj){
	trim(Obj);
	if (Obj.value != ''){
		if(Mascara(Obj.value,'99-9999999') || Mascara(Obj.value,'99-999999')) 
		{
			if ( Obj.value.substring(0,2) == '02')
			{
				if (Obj.value.length != 10)
				{
					alert('El número de télefono no es válido para la región metropolitana.');
					Obj.value='';
					Obj.focus();
					return false;	
				}
				return true; 
			}
			else 
			{ 
				if (Obj.value.substring(0,2) == '09')
				{
					if (Obj.value.length != 10)
					{
						alert('El número de celular no es válido.');
						Obj.value='';
						Obj.focus();
						return false;	
					}
					return true; 
				}
				else
				{
					if (Obj.value.length != 9)
					{
						alert('El número de télefono no es válido para la región.');
						Obj.value='';
						Obj.focus();
						return false;	
					}
					return true; 
				}
			}
		}
		else 
		{
				alert('Ingrese Numero de Teléfono Válido');
				Obj.value='';
				Obj.focus();
				return false;
		}
	}
}
    
/*======================================================================================
Funcion que permite que solo se ingresen numeros
Obj	:	Objeto que posee el string a evaluar
Retorna : Un Booleano
*/
function SoloNumeros(Obj){
		if (!SoloTipo(Obj.value,'9') || Obj.value==''){
			alert('Ingrese solo Numeros');
			Obj.value='';
			Obj.focus();
			return false;
		}else
		return true;
}

/*======================================================================================    
Funcion que permite que solo se ingresen Alfabeticos
Obj	:	Objeto que posee el string a evaluar
Retorna : Un Booleano
*/
function SoloAlfabeticos(Obj){
		if (!SoloTipo(Obj.value,'A')){
			alert('Ingrese solo caracteres Alfabeticos');
			Obj.value='';
			Obj.focus();
			return false;
		}
		return true;
}
    
/*======================================================================================
Funcion que permite que solo se ingresen AlfaNumericos
Obj	:	Objeto que posee el string a evaluar
Retorna : Un Booleano
*/
function SoloAlfaNumericos(Obj){
		if (!SoloTipo(Obj.value,'X')){
			alert('Ingrese solo caracteres Alfanúmericos');
			Obj.value='';
			Obj.focus();
			return false;
		}
		
		return true;
}

/*======================================================================================
Funcion que permite transformar de decimal a hexadecimal y viceversa
Obj1: Objeto que contiene el numero en decimal o hexadecimal
Obj2: Radio botton decimal/hexadecimal
Variable globales banderad y banderah
para permitir correcto funcionamiento de cambio de base
*/
var banderad=true;
var banderah=false;

function CambioBase(Obj1, Obj2){
	Obj1 = trim(Obj1);
	if(esHexadecimal(Obj1.value)){
		if (Obj1.value != '') {
			if (Obj2.value == 'h'){
				if (esEntero(Obj1.value,'+')){
					Obj1.value = dechex(Obj1);
					return true;
				}
			}
			if (Obj2.value == 'd'){
				if(esHexadecimal(Obj1.value)){
					Obj1.value = parseInt(Obj1.value, 16);
					return true;
				}
			}
		}
	}
	else { 
		alert('Numero Ingresado no es valido');
		Obj1.value='';
		Obj1.focus();
		return false;
	}
}
/*-------------------------------------------------------------------
Funcion que verifica si un Email es valido
Obj: Objeto que contiene el Email a evaluar
Retorna : Nulo
*/


function esEmail(Obj) {
    em_val1 = /^\w+@\w+(\.\w+)/
    em_val2 = /^\w+(\.\w+)@\w+(\.\w+)/
    trim(Obj);
    if (Obj.value != ''){
        if(em_val1.test(Obj.value)){
			return true;
		}
		else {
			if(em_val2.test(Obj.value))	{
				return true;
			}
			else {
				return false;
			}
		}
	}
}

/*-------------------------------------------------------------------
Funcion que permite cambiar el cursor del mouse sobre un objeto
Obj: Objeto sobre el cual el cursor cambiara de forma.
Tipos de cursor: 
	help : ayuda
	crosshair: linea vertical y horizontal
	move: cruz con direccion
	hand: mano
	text: linea vertical
	wait: Espera (reloj)
	e-resize: flecha este 
	n-resize: flecha norte
	s-resize: flecha sur
	w-resize: flecha oeste
	ne-resize: flecha noreste
	nw-resize: flecha noroeste
	se-resize: flecha sureste
	sw-resize: flecha suroeste

*/

function CursorMouse(Obj,tipo) {
   Obj.style.cursor=tipo;

}



/*======================================================================================    
Funcion que verifica si una fecha es valida
InString: String a evaluar
Formato:	dma (dia mes ano)
			mda (mes dia ano)
			amd (ano mes dia)
Observación: es utilizada por la funcion Ver_Fecha(Obj) (Siguiente)
Retorna : Un Booleano
*/
function EsFechahora(InString,formato) {
	var anyo
		if (formato == "dma"){
			dia=InString.substring(0,2);
			mes=InString.substring(3,5);
			anyo=InString.substring(6,10);

			hora=InString.substring(11,13);
			minu=InString.substring(14,16);

		}
		if (formato == "mda"){
			mes=InString.substring(0,2);
			dia=InString.substring(3,5);
			anyo=InString.substring(6,10);

			hora=InString.substring(11,13);
			minu=InString.substring(14,16);

		}
		if (formato == "amd"){
			anyo=InString.substring(0,4);
			mes=InString.substring(5,7);
			dia=InString.substring(8,10);

			hora=InString.substring(11,13);
			minu=InString.substring(14,16);

		}

		
		if (dia == '08') dia = '8';	// parseInt("08") == 10		base octogonal
		if (dia == '09') dia = '9';	// parseInt("09") == 11		base octogonal
		if (mes == '08') mes = '8';	// parseInt("08") == 10		base octogonal
		if (mes == '09') mes = '9'; // parseInt("09") == 11		base octogonal
		dia=parseInt(dia);
		mes=parseInt(mes);
		anyo=parseInt(anyo);

		if(!esNumerico(hora)){									
			if(!esNumerico(minu))					
    			hora=parseInt(hora);
    			minu=parseInt(minu);
		
		}
		else
		{
				return false;
		}


		if (hora>8){ 
				if (hora<23)
				{
						 if (minu>59)
						 {				
								return false;
						  }
		    	 }
				 else
				 {
								return false;
				 }
		}
		else
		{
			return false;
							
		}
					




  if (InString.substring(6,10).length< 4) anyo='20' + InString.substring(6,10)
	if (anyo < 1900) return false;    // Anyo mayor a 1900 (por la Base de Datos)
		mes = mes - 1;  // El mes se representa del 0 al 11 (solo para la validación)
		esfecha = new Date(anyo,mes,dia);
		if (dia == esfecha.getDate()){
			if(mes == esfecha.getMonth()){
				if(anyo == esfecha.getFullYear()){
					return true;
				}
			}
		}
		return false;
}