function ExtensionMensaje(obj,largo)
   {
		TotalMensaje = obj.value.length;
		if (TotalMensaje > largo )
		{	
			obj.value = obj.value.substring(0,largo);
		}
return true;
	}

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

function browser()
{
var bName = navigator.appName;
var bVer = parseFloat(navigator.appVersion);
if (bName == "Netscape")
  var browser = "Netscape Navigator"
else
  var browser = bName;
document.write("Usted esta Usando ", browser, " ", bVer, ".");
} 

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

function stopError() {
  return true;
}
/*======================================================================================*/
function cuentaespacios(str,cantmax)
{
str=trim_str(str);
largo=str.length;
largopalabra = 0;
resultado = "";

for (i = 0; i<largo; i++)
{
	c = str.charAt(i);
	if (c == " ")
		largopalabra=0;
	else
		largopalabra = largopalabra + 1;
	
	if (str.charAt(i) == '\n')
	{
		resultado += "<br/>";
		largopalabra = 0;
		c = ''
	}
		
	if (largopalabra == cantmax)
	{
		resultado += "<br/>";
		largopalabra = 0;
	}
	
	resultado += c;
}
return resultado;
}
/*======================================================================================
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));
	//rtrim(Obj);
	//ltrim(Obj);
	//return 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;
}


/*======================================================================================
Verifica comas al interior de un string.
obj:	objeto que contiene string para determinar si tiene
comas en su interior
Retorna: Un Booleano	
*/
function tienecomas(Obj)
{
	InString = Obj.value;
	n = i = 0;
	while (i < InString.length) {
		if (InString.charAt(i) == ",") {
		alert("Elimine comas del nombre del solicitante");
		Obj.focus();
		}
		i++;
	}
	
}

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

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
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ñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ áéíóúàèìòùïüÜ-/.¨ç\!@#$%&_[]{}?¿¡:;,1234567890';
    	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=='\r')
  {
   Char=Replace(Char,'\r','E');
   //alert(Char);
  } 
    if(Char.length != 1) {
    		return false;
    		}
    	Char=Char.toLowerCase();
    	RefString='1234567890abcdefghijklmnñopqrstuvwxyzABCDEFGHIJQLMNÑOPQRSTUVWXYZ áéíóúàèò¨ïüÜ-/.ç!¿¡?() {}[]@#$%&\\_+*:;,\"=<>' + '°´' + '\'' + '\n' + '¬|';
       	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();
	}
}


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

function ChequearRUTDigito(ObjRUT, ObjDigito)
{
alert("ObjRUT");
alert(ObjRUT);
alert("ObjDigito");
alert(ObjDigito);
	                                                                                                 
	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;
}


/*======================================================================================
Agrega el guion a un RUT junto con su Dígito Verificador
*/

function agregadigito(obj)
{
if (obj.value.indexOf('-') < 0) 
{
if (obj.value != '')
{
obj.focus()
var dvr = '0'
	suma = 0
	mult = 2

	strObjRUT = obj.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 != '' )
		obj.value = obj.value + '-' + dvr
	return true;
}
}
}
/*======================================================================================
Corta por el guion a un RUT con su Dígito Verificador
*/

function validaRUT(obj)
{
   var numero = ''
   var n = 0
   var digito = ''

	while (n < obj.value.length)
	{
		if (obj.value.charAt(n) != '-')
			{
			digito = digito + obj.value.substr(n, 1);
			}
		else
			{
			numero = digito;
			digito = '';
			}
	n++;
	}
	
var dvr = '0'
	suma = 0
	mult = 2

	strObjRUT = numero;
	strObjDig = digito;
	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() )
	 {
		alert ("El digito no corresponde");
		obj.value = "";
		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) {
		//Agrega ceros a la fecha		
		if (InString.substring(1,2)=="/") {
		  InString="0"+InString
		}
		if (InString.substring(4,5)=="/"){
		  InString=InString.substring(0,3)+"0"+InString.substring(3,9)
		}
	
		
		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 (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'))&&(!Mascara(Obj.value,'9/9/9999'))&&(!Mascara(Obj.value,'99/9/9999'))&&(!Mascara(Obj.value,'9/99/9999')))
			{
			if (Obj.value!='')
			{
			alert('Formato de fecha es dd/mm/aaaa');
			Obj.value='';
			}
		}
		else if (!EsFecha(Obj.value,'dma')){
			alert('Fecha inválida');
			Obj.value='';

	
		}

}

/*======================================================================================
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,' ')){ 
			alert('Ingrese solo Numeros Enteros');
			Obj.value='';
			Obj.focus();
			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;
}
    
/*======================================================================================
Función que reemplaza en un string un determinado 
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 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 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 {
				alert('Ingrese número de Telefono 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')){
			alert('Ingrese solo números');
			Obj.value='';
			Obj.focus();
			return false;
		}
		return true;
}

/*======================================================================================
Funcion que permite que solo se ingresen numeros
y que esté en el rago del año
Obj	:	Objeto que posee el string a evaluar
Retorna : Un Booleano
*/
function SoloNumerosrango(Obj){
		if (!SoloTipo(Obj.value,'9')){
			alert('Ingrese solo números');
			Obj.value='';
			Obj.focus();
			return false;
		}
		if (Obj.value < 1950)
			{
			alert('Año fuera de rango');
			Obj.value='';
			Obj.focus();
			return false;
			}
		return true;
}

/*======================================================================================
Funcion que permite que solo se ingresen numeros
y que esté en el rago del año
Obj	:	Objeto que posee el string a evaluar
Retorna : Un Booleano
*/
function SoloNumerosTrimestre(Obj){
		if (!SoloTipo(Obj.value,'9')){
			alert('Ingrese solo números');
			Obj.value='';
			Obj.focus();
			return false;
		}
		if ((Obj.value < 1) || (Obj.value > 4))
			{
			alert('Trimestre fuera de rango');
			Obj.value='';
			Obj.focus();
			return false;
			}
		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) {
	
	Obj = trim(Obj)
	//alert(Obj.name)
	band = true;
	InString = Obj.value;
	RefString = 'abcdefghijklmnopqrstuvwxyz-_.@0123456789';
	cont=puntos=0;
	for (i=0;i < InString.length; i++){
		car = InString.charAt(i);
		car = car.toLowerCase();
		if (RefString.indexOf(car, 0) == -1) 
    		band=false;
    	if ( car == '@'){
			cont++;
		}
		if (cont > 0){
			puntos++;
		}
	}
	if (InString.charAt(InString.length - 1) == '.' || cont > 1 || puntos < 1 || InString.indexOf('@.') != -1 || InString.indexOf('.@') != -1 || band == false)
	{
		alert("Error \""+InString+"\" no es una dirección valida de mail.")
		InString='';
		 band=false;
		Obj.value = InString;	
		//document.fo.REP_RUT.focus();
		//Obj.focus()
		
		 return band;	
	}
	else
	{
	 Obj.value = InString;	
	 return band;
	}
}


/*-------------------------------------------------------------------
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;
}

//***************************************************************************************
function Comparar_Fecha(Obj1,Obj2,Formato) {
 // Obj1: objeto que contiene la primera fecha 
 // Obj2: objeto que contiene la segunda fecha 

   String1 = Obj1.value
   String2 = Obj2.value
   // Si los dia y los meses llegan con un valor menor que 10 
	// Se concatena un 0 a cada valor dentro del string  
	if (String1.substring(1,2)=="/") {
	  String1="0"+String1
	}
	if (String1.substring(4,5)=="/"){
	  String1=String1.substring(0,3)+"0"+String1.substring(3,9)
	}
	
	if (String2.substring(1,2)=="/") {
	  String2="0"+String2
	}
	if (String2.substring(4,5)=="/"){
	  String2=String2.substring(0,3)+"0"+String2.substring(3,9)
	 
	}
	
   if (Formato == "dma"){
		dia1=String1.substring(0,2);
		mes1=String1.substring(3,5);
		anyo1=String1.substring(6,10);
		dia2=String2.substring(0,2);
		mes2=String2.substring(3,5);
		anyo2=String2.substring(6,10);
   }

   if (Formato=="amd"){
   		dia1=String1.substring(8,10);
		mes1=String1.substring(5,7);
		anyo1=String1.substring(0,4);
		dia2=String2.substring(8,10);
		mes2=String2.substring(5,7);
		anyo2=String2.substring(0,4);
   }
   if (Formato == "mda"){
   		mes1=String1.substring(0,2);
		dia1=String1.substring(3,5);
		anyo1=String1.substring(6,10);
		mes2=String2.substring(0,2);
		dia2=String2.substring(3,5);
		anyo2=String2.substring(6,10);
   }
   
   if (dia1 == "08")	// parseInt("08") == 10		base octogonal
		dia1 = "8";
	if (dia1 == '09')	// parseInt("09") == 11		base octogonal
		dia1 = "9";
	if (mes1 == "08")	// parseInt("08") == 10		base octogonal
		mes1 = "8";
	if (mes1 == "09")	// parseInt("09") == 11		base octogonal
		mes1 = "9";
	if (dia2 == "08")	// parseInt("08") == 10		base octogonal
		dia2 = "8";
	if (dia2 == '09')	// parseInt("09") == 11		base octogonal
		dia2 = "9";
	if (mes2 == "08")	// parseInt("08") == 10		base octogonal
		mes2 = "8";
	if (mes2 == "09")	// parseInt("09") == 11		base octogonal
		mes2 = "9";
   dia1=parseInt(dia1);
   dia2=parseInt(dia2);
   mes1=parseInt(mes1);
   mes2=parseInt(mes2);
   anyo1=parseInt(anyo1);
   anyo2=parseInt(anyo2);
   
   
   if (anyo1>anyo2)
		{
		return false;
		}
	if ((anyo1==anyo2) && (mes1>mes2))
		{
		return false;
		}
	if ((anyo1==anyo2) && (mes1==mes2) && (dia1>=dia2))
		{
		return false;
		}	  
					  
	 return true;

}

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

// funcion que valida que el trimestre este entre 1 y 4 
	function ValidaTrimestre(obj,piso,techo)
	{
		SoloNumeros(obj);
		if (obj.value=="") return true;
		var monto=obj.value;
		if ((monto<piso) || (monto>techo))
		{
			alert("El trimestre tiene que estar entre "+piso+" y "+techo+"");
			obj.select();
			obj.value="";
			obj.focus();
			return false;
		}
		return true;
	}





/**************Parte Funciones2**********************************/

function checkCDV( dvr )

	{
	  dv = dvr + ""
	  if ( dv != '0' && dv != '1' && dv != '2' && dv != '3' && dv != '4' && dv != '5' && dv != '6' && dv != '7' && dv != '8' && dv != '9' && dv != 'k'  && dv != 'K')
	  {
	    
	    return false;
	  }
	  return true;
	}



	function checkDV( obj_RUT,obj_dv )

	{
	  texto = obj_RUT.value + obj_dv.value  
	  var tmpstr = "";
	  for ( i=0; i < texto.length ; i++ )
	    if ( texto.charAt(i) != ' ' && texto.charAt(i) != '.' && texto.charAt(i) != '-' )
	      tmpstr = tmpstr + texto.charAt(i);
	  texto = tmpstr;
	  
	  largo = texto.length;
	  if ( largo < 2 )
	  {
	    alert("Debe ingresar el RUT completo.")
	    obj_RUT.focus();
	    obj_RUT.select();
	    return false;
	  }

	  if ( largo > 2 )
	    RUT = texto.substring(0, largo - 1);
	  else
	    RUT = texto.charAt(0);
	  dv = texto.charAt(largo-1);
	  if (!checkCDV( dv ))
	  {
		alert("Debe ingresar un dígito verificador válido.");
	    obj_dv.focus();
	    obj_dv.select();
	  }

	  if ( RUT == null || dv == null )
	      return 0

	  var dvr = '0'

	  suma = 0
	  mul  = 2

	  for (i= RUT.length -1 ; i >= 0; i--)
	  {
	    suma = suma + RUT.charAt(i) * mul
	    if (mul == 7)
	      mul = 2
	    else    
	      mul++
	  }


	  res = suma % 11
	  if (res==1)
	    dvr = 'k'
	  else if (res==0)
	    dvr = '0'
	  else
	  {
	    dvi = 11-res
	    dvr = dvi + ""
	  }

	  if ( dvr != dv.toLowerCase() )
	  {
    	    alert("EL RUT es incorrecto.");		    
	  obj_RUT.value = "";
	  obj_dv.value = "";
	    obj_RUT.focus();
            return false
	  }
	      return true
	}

	function checkRUTField(obj_RUT,obj_dv)
	{	  
	  texto = obj_RUT.value + obj_dv.value	  	   
	  var tmpstr = "";
	  for ( i=0; i < texto.length ; i++ )
	    if ( texto.charAt(i) != ' ' && texto.charAt(i) != '.' && texto.charAt(i) != '-' )
	      tmpstr = tmpstr + texto.charAt(i);
	  texto = tmpstr;	  
	  largo = texto.length;

	  if ( largo < 2 )
	  {
	    alert("Debe ingresar el RUT completo.")
	    obj_RUT.select();
	    obj_dv.value = "";
	    obj_RUT.focus();
	    return false;
	  }


	  for (i=0; i < largo ; i++ )
	  { 
	    if ( texto.charAt(i) !="0" && texto.charAt(i) != "1" && texto.charAt(i) !="2" && texto.charAt(i) != "3" && texto.charAt(i) != "4" && texto.charAt(i) !="5" && texto.charAt(i) != "6" && texto.charAt(i) != "7" && texto.charAt(i) !="8" && texto.charAt(i) != "9" && texto.charAt(i) !="k" && texto.charAt(i) != "K" ) 
	    {
	      alert("El valor ingresado no corresponde a un RUT válido.");
			obj_RUT.select();			
			obj_dv.value = "";
			obj_RUT.focus();
			return false;
	    }
	  }


	  var invertido = "";

	  for ( i=(largo-1),j=0; i>=0; i--,j++ )
	    invertido = invertido + texto.charAt(i);


	  var dtexto = "";

	  dtexto = dtexto + invertido.charAt(0);
	  dtexto = dtexto + '-';
	  cnt = 0;

	  for ( i=1,j=2; i<largo; i++,j++ )
	  {
	    if ( cnt == 3 )
	    {
	      dtexto = dtexto + '.';
	      j++;
		  dtexto = dtexto + invertido.charAt(i);
	      cnt = 1;
	    }
	    else
	    { 
	      dtexto = dtexto + invertido.charAt(i);
	      cnt++;
	    }
	  }

	  invertido = "";

	  for ( i=(dtexto.length-1),j=0; i>=2; i--,j++ )
		if (dtexto.charAt(i) == "k")
			invertido = invertido + "K";		
		else{
			invertido = invertido + dtexto.charAt(i);
			obj_RUT.value = invertido;  
		}
		
		if (obj_dv.value == "k")
		{
			obj_dv.value="K"		
		}
	  if ( checkDV(obj_RUT,obj_dv) )
	    return true;
	  return false;

	}
	


//esta funcion trunca pero debo cambiarla por que esta poco eficiente
function trunca(numero,decimales) 
	{   
		numero=numero+"";
		largo=numero.length;
		i=0;
		if (decimales==0) return Math.round(numero);
		if (numero.substr(i,1)==".") strnumero="0"
		else
			while ((numero.substr(i,1)!=".") && (i<largo))
			{
				strnumero=numero.substr(0,i+1);
				i++;
			}
		if (i<largo)
		{
			i++;
			strdecimal=numero.substr(i,(decimales));
			if (numero.substr((i+decimales),1)>="5")
			{
				strdecimal=(parseInt(strdecimal)+1);
				numero=strnumero+"."+strdecimal;
			}
			else
			{
				numero=strnumero+"."+strdecimal;
			}
		}
		return numero;		
	}
	

// funcion para validar las fechas del formulario 

	function valFechas(a, m ,d)
	{
		newdate = new Date(a,m-1,d);
		if ((parseFloat(newdate.getDate()) == parseFloat(d)) &&
		(parseFloat(1+newdate.getMonth()) == parseFloat(m)) &&
		(parseFloat(getFullYearParam(newdate)) == parseFloat(a)))
		return true;
		else
		return false;
	}	

	function getFullYearParam(yr)
	{
		var y = yr.getYear();
		if (y < 1000) y += 1900;
		return y;
	}
	
// funcion para validar que el contenido de un sea numerico
	function camponum(obj)
	{
	
		if (isNaN(obj.value))
		{
			alert("El contenido de este campo debe ser numérico");
			obj.focus();
			obj.select();
			obj.value="";
			return false;
		}		
		return true;

	}

// funcion para validar telefonos 

	function campotelefono(obj)
	{
	var strfono=obj.value;
		camponum(obj);
		strfono=obj.value;
		if ((strfono.length>0) && (strfono.length<6))
		{
			alert("El campo Teléfono debe contar a lo menos con 6 Digitos");
			obj.select();
			obj.value="";
			obj.focus();
			return false;
		}

		return true;

	}


// valida las letras que tienen tilde
	function Tilde(Simbolo)
	{
	 flag=0
	if (Simbolo=="") return true
	var tildes= new Array("Á","É","Í","Ó","Ú","á","é","í","ó","ú","ñ","Ñ")
	for(i=0;i<tildes.length;i++)
	{
	//	alert("Simbolo "+Simbolo+"tildes "+tildes[i])
		if (tildes[i]==Simbolo) flag=1
	}
	if (flag==1) return true;
	else return false;
	}
// valida  que los contenidos de un campo sean alfabéticos

	function campoalfab(obj)
	{
		var largo
		var contador=0;
		var unicode;
		var cadena;
		var flag=0;
		
		if ((obj.type=="select-one")|| (obj.type=="button")) return;
		cadena=obj.value;
		largo=cadena.length;
		if (largo==0) return;
		do
		{
			unicode=cadena.charCodeAt(contador);
			letra=""
			letra=cadena.substr(contador,1)
			if (!(((unicode>=65) && (unicode<=90)) || ((unicode>=97) && (unicode<=122)) || (unicode==32) ||(Tilde(letra)))) 
			{
				flag=1;
			}	
			contador++;
		}while (contador<largo);
		if (flag==1)
		{
			alert("El contenido de este campo debe ser Alfabético");
			obj.value="";
			obj.focus();
		} 
		return;
	}
	function campocorreo(obj)
	{
		var largo
		var contador=0;
		var unicode;
		var cadena;
		var flag=0;
		if ((obj.type=="select-one")|| (obj.type=="button")) return;
		cadena=obj.value;
		largo=cadena.length;
		if (largo==0) return;
		if (largo<5) flag=0;
		else
		{
			do
			{
				unicode=cadena.charCodeAt(contador);
				if (unicode==64) flag=1;				
				contador++;
			}while (contador<largo);
		}
		if (flag!=1)
		{
			alert("Este no es un Correo Electronico Válido");
			obj.value="";
			obj.focus();
		} 
		return;
	}
	

	function borraDv(RUT,dv)
	{
		dv.value="";		
		camponum(RUT);		
		return;
	}	
	
// esta funcion genera un objeto que contiene una edad dividida en a, m , d
	function Edad (a,m,d)
	{ 
		this.anno=a;
		this.mes=m;
		this.dia=d;
	}
	
// funcion que entrega la cantidad de dias que tiene un mes X	
	function DiasMes(Mes)
	{
		if ((Mes==0) || (Mes==2) || (Mes==4) || (Mes==6) ||(Mes==7) ||(Mes==9) ||(Mes==11)) return(31);
		if ((Mes==3) || (Mes==5) || (Mes==8) || (Mes==10)) return(30); 
		if (Mes==1)
		{
			hoy= new Date()
			anno=hoy.getFullYear()
			if ((anno%4)==0) return 29;
			else return 28;
		}	
	}

// funcion que entrega la edad actual de acuerdo a la edad actuarial generada por la 
// funcion EdadActual
	function EdadNeta(EdadActuarial)
	{
		var resultado,resultado2,edad
		
		if (EdadActuarial.length<=5) 
		{	
			resultado=parseInt(EdadActuarial.substring(0,1));
			if (parseInt(EdadActuarial.substring(1,4))>=601){	
				edad=resultado+1
			}
			else{
				edad=resultado
			}
		}	
		else 
		{
			resultado=parseInt(EdadActuarial.substring(0,2));			
			resultado2= EdadActuarial.substring(3,6)			
			if (resultado2>='601'){
				edad=resultado+1
			}
			else{
				edad=resultado
			}
				
			
		}
		return edad
	}
		

// funcion que entrega la edad actual para una fecha de nacimiento entregada
	
	function EdadActual(FechaNac)
	{
		var annos,AnnoHoy,AnnoNacimiento;
		var meses,MesHoy,MesNacimiento;
		var dias,DiaHoy,DiaNacimiento;
		
		FechaHoy=new Date()	;
		AnnoHoy=FechaHoy.getFullYear();
		MesHoy=FechaHoy.getMonth() + 1;
		DiaHoy=FechaHoy.getDate();
	
		AnnoNacimiento=FechaNac.anno;
		MesNacimiento=FechaNac.mes;
//MesNacimiento=FechaNac.mes-1;
		DiaNacimiento=FechaNac.dia;
		dias=Math.abs(DiaHoy-DiaNacimiento);
//dias=DiaHoy-DiaNacimiento
		if (dias < 0)
		{
			if (MesHoy==0) MesHoy=11;
			 else MesHoy--;
			dias=(DiaHoy+DiasMes(MesHoy)-DiaNacimiento);
		}
	
		meses=Math.abs(MesHoy-MesNacimiento);
//meses=MesHoy-MesNacimiento;
	
		if (meses < 0)
		{
			meses=MesHoy+12-MesNacimiento;			
			AnnoHoy--;
		}
		annos=AnnoHoy-AnnoNacimiento;
		if (annos==0) annos="00"
		if (dias<10) dias="0"+dias;
		if (meses<10) meses="0"+meses;
	        //alert(annos);
		//alert(meses);
		//alert(dias);
		return (""+annos+meses+dias);	

	}		
	

// funcion que entrega la edad actual para una fecha de nacimiento entregada, Solo Cotizar
	
	function EdadActualCotizar(dia,mes,anyo)
	{
		var annos,AnnoHoy,AnnoNacimiento;
		var meses,MesHoy,MesNacimiento;
		var dias,DiaHoy,DiaNacimiento;
		
		FechaHoy=new Date()	;
		AnnoHoy=FechaHoy.getFullYear();
		MesHoy=FechaHoy.getMonth()+1;
		DiaHoy=FechaHoy.getDate();

		AnnoNacimiento=anyo;
		MesNacimiento=mes;
		DiaNacimiento=dia;

		dias=DiaHoy-DiaNacimiento;
		dias=Math.abs(dias);

		if (dias < 0)
		{
			if (MesHoy==0) MesHoy=11;
			 else MesHoy--;
			dias=(DiaHoy+DiasMes(MesHoy)-DiaNacimiento);
		}
	//	alert(MesHoy);
	//	alert(MesNacimiento);
		meses=MesHoy-MesNacimiento;
 		meses=Math.abs(meses)
	//	alert(meses + "*");
	
		if (meses < 0)
		{
			meses=MesHoy+12-MesNacimiento;
			AnnoHoy--;
		}
		annos=AnnoHoy-AnnoNacimiento;
		
		if (dias<10) dias="0"+dias;
		if (meses<10) meses="0"+meses;
		if (annos<10) annos="0"+annos;
		alert(annos);
		alert(meses);
		alert(dias);
		return (""+annos+meses+dias);	
	}		






//  esta funcion comprueba si una cadena contiene algúna letra o numero
	function ContieneLetraONum(obj)
	{
	  var largo
	  var contador=0;
	  var unicode;
	  var cadena;
	  if ((obj.type=="select-one")|| (obj.type=="button")) return true;
	  largo=obj.length;
	  cadena=obj.value;
	  do
	  {
		unicode=cadena.charCodeAt(contador);
		if (((unicode>=65) && (unicode<=90)) || ((unicode>=97) && (unicode<=122)) || ((unicode>=48) && (unicode<=57))) return true;
		contador++;
	  }while (contador<largo);
	  return false; 
	  
	}
	
// funcion valida capital rango 3000..10000 
	function ValidaCapital(obj,piso,techo)
	{
		camponum(obj);
		if (obj.value=="") return true;
		var monto=obj.value;
		if ((monto<piso) || (monto>techo))
		{
			alert("El Monto Mínimo debe ser igual o superior a U.F. "+piso+" \n"+
					"El  Monto Máximo debe ser igual o inferior a U.F. "+techo+" \n");
			obj.select();
			obj.value="";
			obj.focus();
			return false;
		}
		return true;
	}


/**************************************************************
 Replace: Returns a string in which a specified substring has 
          been replaced with another substring a specified 
          number of times.

 Parameters:
      Expression = String expression containing substring to 
                   replace
      Find       = Substring being searched for.
      Replace    = Replacement substring.

 Returns: String
***************************************************************/

function Replace(Expression, Find, Replace)
{
	var temp = Expression;
	var a = 0;

	for (var i = 0; i < Expression.length; i++) 
	{
		a = temp.indexOf(Find);
		if (a == -1)
			break
		else
			temp = temp.substring(0, a) + Replace + temp.substring((a + Find.length));
	}

	return temp;
}

//formatea una expresion con los numeros decimales que se le indiquen

function FormatNumber(Expression, NumDigitsAfterDecimal)
{

	var iNumDecimals = NumDigitsAfterDecimal;
	var dbInVal = Expression;
	var bNegative = false;
	var iInVal = 0;
	var strInVal
	var strWhole = "", strDec = "";
	var strTemp = "", strOut = "";
	var iLen = 0;
	
	if (dbInVal < 0)
	{
		bNegative = true;
		dbInVal *= -1;
	}

	dbInVal = dbInVal * Math.pow(10, iNumDecimals)
	iInVal = parseInt(dbInVal);
	if ((dbInVal - iInVal) >= .5)
	{
		iInVal++;
	}
	strInVal = iInVal + "";
	strWhole = strInVal.substring(0, (strInVal.length - iNumDecimals));
	strDec = strInVal.substring((strInVal.length - iNumDecimals), strInVal.length);
	while (strDec.length < iNumDecimals)
	{
		strDec = "0" + strDec;
	}
	iLen = strWhole.length;
	if (iLen >= 3)
	{
		while (iLen > 0)
		{
			strTemp = strWhole.substring(iLen - 3, iLen);
			if (strTemp.length == 3)
			{
				strOut = "" + strTemp + strOut;
				iLen -= 3;
			}
			else
			{
				strOut = strTemp + strOut;
				iLen = 0;
			}
		}
		if (strOut.substring(0, 1) == ".")
		{
			strWhole = strOut.substring(1, strOut.length);
		}
		else
		{
			strWhole = strOut;
		}
	}
	if (bNegative)
	{
		return "-" + strWhole + "." + strDec;
	}
	else
	{
		return strWhole + "0." + strDec;
	}
}
/*======================================================================================
Permite validar la entradas de los campos de un formulario con valores numericos
Obj. objeto input tipo text, tipo:tipo de dato a validar
cantidad: Numero de caracteres desde la izquierda
*/
function valida(Obj,tipo)
{
 if (tipo=='i')
  if (!(esEntero(Obj.value,'+')))
    {
     alert('Valor del campo incorrecto');
     Obj.focus();
     Obj.value='';
    }
 if (tipo=='r')   
  if (!(esReal(Obj.value,'+')))
    {
     alert('Valor del campo incorrecto');
     Obj.value='';
     Obj.focus();
    }  
 if (Obj.value=='')   
    {
    Obj.value='0';
    }
}

/*======================================================================================
Las siguientes 3 funciones permiten validar el RUT ingresado de la forma "1111111111-1" 
Obj. objeto input 
*/
function checkFieldRut(obj)
{
 var texto = obj.value;
  var tmpstr = "";
  for ( i=0; i < texto.length ; i++ )
    if ( texto.charAt(i) != ' ' && texto.charAt(i) != '.' && texto.charAt(i) != '-' )
      tmpstr = tmpstr + texto.charAt(i);
  texto = tmpstr;
  largo = texto.length;
 //alert(texto)
// [VARM+]
  tmpstr = "";
  for ( i=0; texto.charAt(i) == '0' ; i++ );
  for (; i < texto.length ; i++ )
     tmpstr = tmpstr + texto.charAt(i);
  texto = tmpstr;
  largo = texto.length;
// [VARM-]
 

  if ( largo < 2 )
  {
   // alert("R.U.T erroneo. Debe ingresar el R.U.T completo");
    alert("RUT erroneo. Revise el RUT ingresado");
    obj.value = "";
    //obj.select();
    //obj.focus();
    return false;
  }
  var invertido = "";
 
  for ( i=(largo-1),j=0; i>=0; i--,j++ )
    invertido = invertido + texto.charAt(i);
 

  var dtexto = "";
 
  dtexto = dtexto + invertido.charAt(0);
  dtexto = dtexto + '-';
  cnt = 0;
 
  for ( i=1,j=2; i<largo; i++,j++ )
  {
    if ( cnt == 3 )
    {
      dtexto = dtexto + '.';
      j++;
      dtexto = dtexto + invertido.charAt(i);
      cnt = 1;
    }
    else
    {
      dtexto = dtexto + invertido.charAt(i);
      cnt++;
    }
  }
 
  invertido = "";
 
  for ( i=(dtexto.length-1),j=0; i>=0; i--,j++ )
    invertido = invertido + dtexto.charAt(i);
 
  obj.value = invertido;
 
  if (!checkDVFieldRUT(texto))
    {
     obj.value = "";
	 //obj.select();
	 //obj.focus();
	 return false;
	 }
  return true;	 
}



function checkDVFieldRUT(cRUT)
{
  largo = cRUT.length;
  if(largo < 2){
    return false;
  }
  if(largo > 2){
    RUT = cRUT.substring(0, largo - 1);
  }
  else{
    RUT = cRUT.charAt(0);
  }
  dv = cRUT.charAt(largo-1);
 
  if(!checkCDVFieldRUT(dv))
     return false;
 
  if(RUT == null || dv == null){
      return false;
  }
 
  var dvr = '0';
  suma = 0;
  mul  = 2;
  for (i= RUT.length -1 ; i >= 0; i--){
    suma = suma + RUT.charAt(i) * mul;
    if(mul == 7){
      mul = 2;
    }
    else{
      mul++;
    }
  }
  res = suma % 11;
  if (res==1){
    dvr = 'k';
  }
  else{
    if(res==0){
      dvr = '0';
    }
    else{
      dvi = 11-res;
      dvr = dvi + "";
    }
  }
  if(dvr != dv.toLowerCase()){
     //alert("R.U.T erroneo. El Dígito no corresponde");
      alert("RUT erroneo. Revise el RUT ingresado");
    return false;
  }
  return true;
}
 
function checkCDVFieldRUT(dvr)
{
  dv = dvr + "";
  if(dv != '0' && dv != '1' && dv != '2' && dv != '3' && dv != '4' && dv != '5' && dv != '6' && dv != '7' && dv != '8' && dv != '9' && dv != 'k'  && dv != 'K'){
    //alert("RUT erroneo. Debe ingresar un Dígto válido");
     alert("RUT erroneo. Revise el RUT ingresado");
    return false;
  }
  return true;
}

/*======================================================================================
Funcion que elimina los blancos a la izquierda de un string.
*/
function ltrim_str(str)
{
	
	InString = str;
	n = i = 0;
	while (i < InString.length) {
		if (InString.charAt(i) != " ") {
			n = i
			break
		}
		i++
	}
	if (n == 0 && i == InString.length)
		str = ''
	else
		str = InString.substring(n, InString.length)
	return str;
}

/*======================================================================================
Elimina los blancos a la derecha de un string.
*/
function rtrim_str(str) 
{
	InString = str;
	n = i = InString.length
	while (i > 0) {
		if (InString.charAt(i - 1) != " ") {
			n = i
			break
		}
		i--
	}
	if (n == InString.length && i == 0)
		str = ''
	else
		str = InString.substring(0, n);
	return str;
}

/*======================================================================================
Elimina los blancos de los extremos de un string.
*/

function trim_str(str)
{
	return rtrim_str(ltrim_str(str));
}