/*******************************************************************************
'
' Tipo: JS
' Nombre: funciones
' Descripción: Funciones comunes para las páginas
' 
' Autor: Anabel Surachi
' 
' Registro de modificaciones
' --------------------------
' Autor	   Fecha	 Motivo
' -----    ------	 ----------------------
' Anabel   061226	 Creación del fuente
*******************************************************************************/ 

// Reemplaza la tecla presionada por otra.
function ReemplazarTecla (e, tecla)
{	
	if (document.all) {
		e.keyCode = tecla;
	}	
	else {
		e.which = tecla;
	}
}
// Anula el evento realizado 
function AnularEvento (e)
{	
	if (document.all) {
		e.returnValue = false;
	}	
	else {
		e.preventDefault();
		e.stopPropagation();
	}
}
/* Acepta determinados teclas presionadas dependiendo el tipo. 
   Para tipo:
   'E': Solo acepta números enteros;
   'D': Solo número decimales positivos (del 0 al 9, la coma y el punto lo remplaza en coma).
   'F': Solo caracteres de fecha (números y la /);
   'H': Solo caracteres de hora (números y la :);
   'C': Solo numero y letras;
   'U': Solo letras y cambia las minúsculas por mayúsculas;
   'L': Solo letras y cambia las mayúsculas por minúsculas; 
*/
function ValidarTexto(e, tipo)
{
	var tecla = (document.all) ? e.keyCode : e.which;		
    var ac;    
    
    if ((tecla == 13) || (tecla == 8) || (tecla == 9))
    {
		ac = true;
    }
    else
    {
		switch (tipo)
        {
			case 'E': ac = (tecla >= 48) && (tecla <= 57); break;
		    case 'D':
				if ((tecla >= 48) && (tecla <= 57) || (tecla == 44)) {
					ac = true;
				}
				else {
					if (tecla == 46) {
						tecla = tecla - 2;
						var x = ReemplazarTecla (e, tecla);
						ac = true;
                    }
					else
					{   
						ac = false;
					}
                }
				break;
             case 'F': ac = ((tecla >= 47) && (tecla <= 57)); break;                     
             case 'H': ac = ((tecla >= 48) && (tecla <= 58)); break;
             case 'U':
				if ((tecla >= 65 && tecla <= 90)){
					ac = true;
                }
                else
                {
					if ((tecla >= 97 && tecla <= 122) || (tecla == 241)) {
					    tecla = tecla - 32;
						var x = ReemplazarTecla (e, tecla);
						ac = true;
                    }
					else  {
                        ac = false;
					}
				}
				break;		
			case 'C':
			if ((tecla >= 48) && (tecla <= 57) || (tecla >= 65 && tecla <= 90)) {
				ac = true;
			} 
			else {
				if ((tecla >= 97 && tecla <= 122) || (tecla == 241)) {
				    tecla = tecla - 32;
					var x = ReemplazarTecla (e, tecla);
					ac = true;
                }
				else  
				{
                    ac = false;
				}
			}
			break;
		}
	}	
	if (!(ac)) {		
		var x =	AnularEvento(e);		
	}	
    return ac;
}

//------------------------------------------------------------------------------
// ChequearSepFecha : Chequea el separador del la fecha.
//------------------------------------------------------------------------------

function ChequearSepFecha(valor){
	var bOk = false;		
	bOk = bOk || ((valor.charAt(2) == "/") && (valor.charAt(5) == "/"));
	return bOk;
}
//------------------------------------------------------------------------------
// ChequearEsDigito : Chequea si se ingreso un dígito.
//------------------------------------------------------------------------------
function  ChequearEsDigito(sChr){
	var sCod = sChr.charCodeAt(0);
	return ((sCod > 47) && (sCod < 58));
}

//------------------------------------------------------------------------------
// ObtenerFinMes : Obtiene el último día del mes.
//------------------------------------------------------------------------------

function ObtenerFinMes(valor){
	var nMes = parseInt(valor.substr(3, 2), 10);	
	var nRes = 0;
	switch (nMes){		
		case 2: nRes = ChequearEsBisiesto(valor)?29:28; break;		
		case 4,6,9,11: nRes = 30; break;
		default: nRes = 31; break;		
	}
	return nRes;
}
//------------------------------------------------------------------------------
// ChequearEsBisiesto : Chequea si el año es bisiesto
//------------------------------------------------------------------------------

function ChequearEsBisiesto(valor) {  
	var bOk = false;
	var nAnio = valor.substr(6);
    bOk = bOk && (((nAnio % 4 == 0) && (nAnio % 100 != 0)) || (nAnio % 400 == 0));  
    return bOk;
} 
//------------------------------------------------------------------------------
// ChequearDia : Chequea si se ingresa un día valido
//------------------------------------------------------------------------------

function ChequearDia(valor){
	var bOk = false;
	var nDia = parseInt(valor.substr(0, 2), 10);
	bOk = bOk || ((nDia >= 1) && (nDia <= ObtenerFinMes(valor)));
	return bOk;
}
//------------------------------------------------------------------------------
// ChequearMes : Chequea si ingresa un mes valido
//------------------------------------------------------------------------------

function ChequearMes(valor){
	var bOk = false;
	var nMes = parseInt(valor.substr(3, 2), 10);
	bOk = bOk || ((nMes >= 1) && (nMes <= 12));
	return bOk;
}
//------------------------------------------------------------------------------
// ChequearAnio : Chequea si se ingresa un año valido
//------------------------------------------------------------------------------
function ChequearAnio(valor){
	var bOk = true;
	var nAnio = valor.substr(6);
	bOk = bOk && ((nAnio.length == 4));	
	if (bOk){
		for (var i = 0; i < nAnio.length; i++){
			bOk = bOk && ChequearEsDigito(nAnio.charAt(i));
		}
	}
	nAnio = parseInt(nAnio, 10);
	bOk = bOk && ((nAnio > 2006) && (nAnio < 2051));
	return bOk;
}
//------------------------------------------------------------------------------
// ChequearFecha : Chequea si se ingresa una fecha valido
//------------------------------------------------------------------------------

function ChequearFecha(valor){
	var bOk = true;	
	bOk = bOk && (ChequearAnio(valor));
	bOk = bOk && (ChequearMes(valor));
	bOk = bOk && (ChequearDia(valor));
	bOk = bOk && (ChequearSepFecha(valor));
	return bOk;
	
}
//------------------------------------------------------------------------------
// ChequearTipo : Chequea el campo según el tipo.
// 'E': Solo acepta números enteros positivos;
// 'D': Solo número decimales positivos (acepta del 0 al 9 y la coma).
// 'H': Solo caracteres de hora (acepta números y la :);              
// 'CPF': Código de Pago Facil Segunda Parte (Empiece con una letra y siga con 5 dígitos);  
//------------------------------------------------------------------------------

function ChequearTipo(valor, tipo){
    var bOk = true;	
    switch (tipo)
        {
			case 'E': var sTipoValido = /^(?:\+|-)?\d+$/; break;
			case 'D': var sTipoValido = /^(?:\+|-)?\d+\,?\d*$/; break; 
			case 'H': var sTipoValido = /([01]\d|2[0-3]):[0-5]\d:[0-5]\d/; break;
			case 'CPF': var sTipoValido = /^[a-zA-Z]{1}\d{5}$/; break;
		}		
	var matchArray = valor.match(sTipoValido)
	if (matchArray == null) {		
		bOk = false;
	}    
	return bOk;
	
}

//------------------------------------------------------------------------------
// Funciones para el intercambio de imágenes
//------------------------------------------------------------------------------

function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_preloadImages() { //v3.0
  var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
    var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
    if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
}

function MM_findObj(n, d) { //v3.0
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document); return x;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}

//------------------------------------------------------------------------------
// Funciones para el redondeo de números. 
//------------------------------------------------------------------------------

function fnRedondeo2 (str) {

	var valor = trim(str);
	var longitud = valor.length;
	var posPunto = valor.indexOf('.');
	var retVal = valor.toString();
	var valorAux = 0;

	if (posPunto == -1) {
		retVal += ".00";
	}
	else {
		if ((longitud - posPunto) <= 2) {
			retVal += "00";
		}
		else {
			var ultDec = valor.charAt(posPunto+3);
			if (parseInt(ultDec) >= 5){
				valorAux = parseInt(valor.substring(posPunto+1,posPunto+3)) + 1
				retVal = valor.substring(0,posPunto+1) + valorAux.toString();
			}
		}
		retVal = retVal.substring(0,posPunto + 3);
	}
	return retVal;
}
//------------------------------------------------------------------------------
// Funciones para el formateo de cadenas. Elimina los espacios.
//------------------------------------------------------------------------------

function trim(strText){ 
    // this will get rid of leading spaces 
    while (strText.substring(0,1) == ' ') 
        strText = strText.substring(1, strText.length);

    // this will get rid of trailing spaces 
    while (strText.substring(strText.length-1,strText.length) == ' ')
        strText = strText.substring(0, strText.length-1);

   return strText;
} 

//------------------------------------------------------------------------------
// Funciones para abrir una nueva ventana
//------------------------------------------------------------------------------
function AbrirVentana (Url, Nombre, Alto, Ancho) {
	window.open (Url, Nombre, "toolbar=no,menubar=no,location=no,resizable=no,scrollbars=no,height="+Alto+",width="+Ancho+",top=0,left=0");
}
//-----------------------------------------------------------------------------
// Chequeo de la dirección de correo electrónico
//-----------------------------------------------------------------------------

function ChequearEMail (emailStr) {	
	
	/* Formato para ver que la dirección verifica el formato user@domain */
	var emailPat =/^(.+)@(.+)$/
	
	/* Formato para chequear que no contiene los caracteres ( ) < > @ , ; : \ " . [ ]    */
	var specialChars = "\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";
	
	/* Caracteres que no están permitidos en la dirección de correo */
	var validChars = "\[^\\s" + specialChars + "\]"
	
	/* Para cuando sea una dirección con cadena entrecomillada.  v.g. "anabel surachi"@bitios.com */
	var quotedUser = "(\"[^\"]*\")"
	
	/* Para cuando se pone la dirección IP en lugar del dominio.  v.g. jose@[123.124.233.4]
	   NOTA: Los corchetes son necesarios. */
	var ipDomainPat =/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/

	var atom = validChars + '+'

	var word = "(" + atom + "|" + quotedUser + ")"

	// Formato que describe la estrutura el usuario
	var userPat = new RegExp("^" + word + "(\\." + word + ")*$")

	/* Formato para un dominio simbolico */
	var domainPat = new RegExp("^" + atom + "(\\." + atom +")*$")
	
	var matchArray = emailStr.match(emailPat)	
	if (matchArray == null) {		
		return false
	}
	var user = matchArray[1]
	var domain = matchArray[2]
	
	// Si el usuario es valida
	if (user.match(userPat) == null) {
	    // Usuario de correo no es valido	    
	    return false;
	}

	/* Chequeamos si una dirección no simbólica es válida. */
	var IPArray = domain.match(ipDomainPat)
	if (IPArray != null) {
	    // this is an IP address
		  for (var i=1;i<=4;i++) {
		    if (IPArray[i]>255) {		        
			return false
		    }
	    }
	    return true
	}

	// Dominio simbólico
	var domainArray = domain.match(domainPat)
	if (domainArray == null) {		
	    return false
	}

	/* Chequeamos que el dominio principal (.com, .net,...) es valido
	o pertenece a algú pais (.es, .uk, ...). */


	var atomPat = new RegExp(atom,"g")
	var domArr = domain.match(atomPat)
	var len = domArr.length
	if (domArr[domArr.length-1].length<2 ||
	    domArr[domArr.length-1].length>3) {
	   // La dirección debe finalizar con dos o tres letras.	   
	   return false
	}

	// Nos aseguramos que una máquina precede al dominio hostname
	if (len < 2) {	   
	   return false
	}

	// Todo es valido
	return true;
}