/************************************************************
 *      Biblioteca de Funciones de Manejo de String con     *
 *      parámetro principal como Objeto, Versión 1.3        *
 *      Autor:           Hernán Mallea Soto                 *
 *      Versión 1.3:  09 - Dic - 2008                       *
 *      - Se incorpora funciones de Mensaje, left y right   *
 *      - Se mejora función isNumber, para validación de    *
 *        números enteros o reales/decimales.               *
 *      Versión 1.2:  27 - Sep - 2005                       *
 *      - Se incorpora función de validación de formato de  *
 *        correo electrónico.                               *
 *      Versión 1.1:     14 - Feb - 2001                    *
 *      Versión 1.0:     24 - Nov - 1999                    *
 ************************************************************/

/*	Elimina los blancos a la izquierda de un string.
	Devuelve un Objeto	*/
function ltrim(Obj) {
//	Obj:	objeto que contiene string a eliminar blancos de la izquierda

	strValor = Obj.value;
	n = i = 0;
	while (i < strValor.length) {
		if (strValor.charAt(i) != ' ') {
			n = i;
			break;
		}
		i++;
	}
	if (n == 0 && i == strValor.length)
		Obj.value = ''
	else
		Obj.value = strValor.substring(n, strValor.length);
	return Obj;
}

/*	Elimina los blancos a la derecha de un string.
	Devuelve un Objeto	*/
function rtrim(Obj) {
//	Obj:	objeto que contiene string a eliminar blancos de la derecha

	strValor = Obj.value;
	n = i = strValor.length;
	while (i > 0) {
		if (strValor.charAt(i - 1) != ' ') {
			n = i;
			break;
		}
		i--;
	}
	if (n == strValor.length && i == 0)
		Obj.value = ''
	else
		Obj.value = strValor.substring(0, n);
	return Obj;
}

/*	Elimina los blancos de los extremos de un string.
	Devuelve un Objeto	*/
function trim(Obj) {
//	Obj:	objeto que contiene string a eliminar blancos de los extremos

	return rtrim(ltrim(Obj));
}

/*	Elimina los blancos de los extremos y blancos repetidos al interior de un string,
	dejando sólo uno.
	Devuelve un Objeto	*/
function itrim(Obj) {
//	Obj:	objeto que contiene string a eliminar blancos al interior, dejando uno
	var strTrim = '';

	Obj = trim(Obj);
	strValor = Obj.value;
	i = 0;
	while ((n = strValor.indexOf(' ', i)) >= 0) {
		strTrim += strValor.substring(i, n + 1);
		i = n + 1;
		while (strValor.charAt(i) == ' ')
			i++;
	}
	strTrim += strValor.substring(i, strValor.length);
	Obj.value = strTrim;
	return Obj;
}

/*	Verifica blancos al interior de un string.
	Devuelve un Booleano	*/
function hasSpaces(Obj) {
//	Obj:	objeto que contiene string para determinar si tiene
//				blancos en su interior

	strValor = Obj.value;
	n = i = 0;
	while (i < strValor.length) {
		if (strValor.charAt(i) == ' ') {
			return true;
		}
		i++;
	}
	return false;
}


/*	Invierte el orden de los caracteres de un string.
	Devuelve un Objeto	*/
function strReverse(Obj) {
//	Obj:	objeto que contiene string a invertir

	var strRever = '';
	
	strValor = Obj.value;
	for (var i = strValor.length - 1; i >= 0; i--)
		strRever += strValor.charAt(i);
	return strRever;
}

/*	Convierte los caracteres de un string a mayúsculas.
	Devuelve un Objeto	*/
function ucase(Obj){
//	Obj:	objeto que contiene string a convertir caracteres a mayúsculas

	Obj = trim(Obj);
	if (Obj.value != '')
		Obj.value = Obj.value.toUpperCase();
	return Obj;
}

/*	Convierte los caracteres de un string a minúsculas.
	Devuelve un Objeto	*/
function lcase(Obj){
//	Obj:	objeto que contiene string a convertir caracteres a minúsculas

	Obj = trim(Obj);
	if (Obj.value != ''){
		Obj.value = Obj.value.toLowerCase();
	}
	return Obj;
}

/*	Convierte el primer caracter de un string a mayúsculas.
	Devuelve un Objeto	*/
function pcase(Obj) {
//	Obj:	objeto que contiene string con primer caracter en mayúsculas

	Obj = itrim(Obj);
	strValor = Obj.value;
	Obj.value = strValor.charAt(0).toUpperCase() + strValor.substring(1, strValor.length).toLowerCase();
	return Obj;
}

/*	Convierte el primer caracter de cada palabra de un string a mayúsculas.
	Devuelve un Objeto	*/
function initcap(Obj) {
//	Obj:	objeto que contiene string con primer caracter de cada palabra en mayúsculas
	var strTrim = '';

	Obj = trim(Obj);
	strValor = Obj.value;
	i = 0;
	while ((n = strValor.indexOf(' ', i)) >= 0) {
		strTrim += strValor.charAt(i).toUpperCase() + strValor.substring(i + 1, n + 1).toLowerCase();
		i = n + 1;
		while (strValor.charAt(i) == ' ')
			i++;
	}
	strTrim += strValor.charAt(i).toUpperCase() + strValor.substring(i + 1, strValor.length).toLowerCase();
	Obj.value = strTrim;
	return Obj;
}

/*	Verifica si los caracteres de un string son alfabéticos.
	Devuelve un Booleano	*/
function isAlpha(Obj) {
//	Obj:	objeto que contiene string a evaluar sí caracteres son alfabéticos
	var strValor = Obj.value.toLowerCase();

    	RefString = 'abcdefghijklmnñopqrstuvwxyz áéíóúü';
	for (i=0; i<=strValor.length; i++)
	    	if (RefString.indexOf(strValor.charAt(i), 0) == -1) {
    			return false;
			break;
		}
   	return true;
}

/*	Verifica si los caracteres de un string son números.
	Devuelve un Booleano	*/
function isNumber(Obj, sTipo, sSigno, sIMsg, sMsg, sSignoDecimal) {
//	Obj:	objeto que contiene string a evaluar sí caracteres son números
//	sTipo:	tipo de número (string): entero (E) o real (R)
//	sSigno:	signo del número (string): sólo positivo (+), sólo negativo (-) o ambos (0)
//	sIMsg:	switch que indica si despliega mensaje (string): todos (T), sólo errores (E) o ninguno (N)
//	sMsg:	mensaje a desplegar en caso de error (string)
//  sSignoDecimal:  Caracter que indica el signo decimal (string)

	var strValor = trim(Obj).value;
	var i = 0;
    var RefString = '0123456789';
	var sTipo = (sTipo == null) ? 'E' : sTipo;
	var sSigno = (sSigno == null) ? '+' : sSigno;
	var sIMsg = (sIMsg == null) ? 'N' : sIMsg;
	var sMsg = (sMsg == null) ? '' : sMsg;
	var sSignoDecimal = (sSignoDecimal == null) ? '' : sSignoDecimal;

	switch (sIMsg) {
	case 'T':
		//Todos
		MC = true;	//Mensajes correctos, mostrar
		MI = true;	//Mensajes incorrectos, mostrar
		break;
	case 'E':
		//Sólo Errores
		MC = false;	//Mensajes correctos, no mostrar
		MI = true;	//Mensajes incorrectos, mostrar
		break;
	case 'N':
		//Ninguno
		MC = false;	//Mensajes correctos, no mostrar
		MI = false;	//Mensajes incorrectos, no mostrar
		break;
	default:
		//Por defecto
		MC = false;	//Mensajes correctos, no mostrar
		MI = true;	//Mensajes incorrectos, mostrar
	}
	
	if (hasSpaces(Obj)) {
		Mensaje(MI, sMsg);
		return false;
	}

	if (sSignoDecimal.length > 1)
		Mensaje(true, 'Error en la asignación del caracter de signo decimal.');
		
	if (sTipo == 'R')
		RefString += sSignoDecimal;
		
	switch (strValor.charAt(i)) {
	case "-":
		//Negativo (-)
		if (sSigno == '+') {
			Mensaje(MI, sMsg);
			return false;
		}
		break;
	case "+":
		//Positivo (+)
		if (sSigno == '-') {
			Mensaje(MI, sMsg);
			return false;
		}
		break;
	default:
		//Por defecto
	    if (RefString.indexOf(strValor.charAt(i), 0) == -1) {
			Mensaje(MI, sMsg);
    		return false;
    	}
	}

	for (i=1; i<=strValor.length; i++) {
		if (RefString.indexOf(strValor.charAt(i), 0) == -1) {
			Mensaje(MI, sMsg);
			return false;
			break;
		}
		if (strValor.charAt(i) == sSignoDecimal)
			RefString = RefString.substring(0, 10);
	}

	//Finalmente, el string es número (entero o real)
	Mensaje(MC, 'Es número.');
	return true;
}

/*	Verifica si los caracteres de un string son alfanuméricos.
	Devuelve un Booleano	*/
function isAlphaNumber(Obj) {
//	Obj:	objeto que contiene string a evaluar sí caracteres son alfanuméricos
	var strValor = Obj.value.toLowerCase();

    	RefString = '0123456789abcdefghijklmnñopqrstuvwxyz áéíóúü';
	for (i=0; i<=strValor.length; i++)
	    	if (RefString.indexOf(strValor.charAt(i), 0) == -1) {
    			return false;
			break;
		}
   	return true;
}

/*	Verifica si string tiene la estructura de dirección de correo email.
	Devuelve un Booleano	*/
function emailCheck (Obj) {
//	Obj:	objeto que contiene string a evaluar sí es email
	var emailPat = /^(.+)@(.+)$/;
	var specialChars = "\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";
	var validChars = "\[^\\s" + specialChars + "\]";
	var quotedUser = "(\"[^\"]*\")";
	var ipDomainPat = /^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;
	var atom = validChars + '+';
	var word = "(" + atom + "|" + quotedUser + ")";
	var userPat = new RegExp("^" + word + "(\\." + word + ")*$");
	var domainPat = new RegExp("^" + atom + "(\\." + atom +")*$");
	var matchArray = Obj.value.match(emailPat);

	if (matchArray == null) {
		alert("Dirección Email está incorrecta. Por favor verifique @ y .");
		return false;
	}

	var user = matchArray[1];
	var domain = matchArray[2];

	if (user.match(userPat) == null) {
	    alert("Username no valido.");
	    return false;
	}

	var IPArray=domain.match(ipDomainPat);
	
	if (IPArray != null) {
		  for (var i = 1; i <= 4; i++) {
		    if (IPArray[i] > 255) {
		        alert("Dirección IP no Valida!");
				return false;
		    }
	    }
	    return true;
	}

	var domainArray = domain.match(domainPat);

	if (domainArray == null) {
		alert("El dominio indicado no existe.");
	    return false;
	}
	
	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) {
		alert("La dirección debe finalizar con 3 letras del dominio o 2 letras del país.");
		return false;
	}
	if (len < 2) {
		alert("Dirección incorrecta");
		return false;
	}
	
	return true;
}

/*	Muestra en mensaje alert en caso de indicador es verdadero.
	Devuelve un String	*/
function Mensaje(IMensaje, Mensaje) {
//	IMensaje:	switch que indica si despliega mensaje, si (s) o no (n)
//	Mensaje:	mensaje a desplegar

	if (IMensaje)
		alert(Mensaje);
}

/*	Extrae el extremo izquierdo de un string.
	Devuelve un Objeto	*/
function left(Obj, iLargo) {
//	Obj:	objeto que contiene string a extraer extremo izquierdo
//	iLargo:	largo de la cadena a ser devuelta (integer)

	var strValor = Obj.value;
	var iLargo = (iLargo == null) ? strValor.length : iLargo;

	Obj.value = strValor.substring(0, iLargo);
	return Obj;
}

/*	Extrae el extremo derecho de un string.
	Devuelve un Objeto	*/
function right(Obj, iLargo) {
//	Obj:	objeto que contiene string a extraer extremo derecho
//	iLargo:	largo de la cadena a ser devuelta (integer)

	var strValor = Obj.value;
	var iLargo = (iLargo == null) ? strValor.length : iLargo;

	Obj.value = strValor.substring(strValor.length - iLargo);
	return Obj;
}