////////CAPTURO EN QUE NAVEGADOR ESTOY TRABAJANDO //////////////////
ns4 = (document.layers)? true:false
ie4 = (document.all)? true:false
////////////////////////////////////////////////////////////////////

function solo_mail(evt){//Esta funcion valida que el campo digitado cumpla con el formato de e-mail; esta funcion se debe llamar mediante el evento onblur.
	if(this.value != ""){
		var patron = /^(.+\@.+\..+)$/;//acepta xxx@xxx.xxx.xxx(REMPLAZAR SI SE ENCUENTRA UNA MEJOR)
		if(this.value.match(patron)){
			return true;
		}else{
			alert("El e_mail digitado no es valido. El campo debe cumplir con el formato de email correcto, ver manual de usuario.");
			this.value = "";
		}
    }
}

function solo_telefono(evt){//Esta funcion valida que el campo digitado cumpla con el formato de e-mail; esta funcion se debe llamar mediante el evento onblur.
	if(this.value != ""){
		var patron = /(\d+([\s\+\-])*)+$/;//permite espacios y guiones.(VALIDACION PERFECTA)
		if(this.value.match(patron)){
			return true;
		}else{
			alert("El telefono digitado no es valido. Debe ingresar solo digitos y espacios o guiones, ver manual de usuario.");
			this.value = "";
		}
	}
    
}

function solo_letras(e){//esta funcion restringe el ingreso de solo caracteres y espacios en un campo de texto dependiendo el navegador.
	if(ns4){
		var key = e.which; 
		return (key <= 13 || (key >= 65 && key <= 90) || (key >= 97 && key <= 122) || key == 32)
	}
	if(ie4){
		var key = event.keyCode; 
		return (key <= 13 || (key >= 65 && key <= 90) || (key >= 97 && key <= 122) || key == 32)
	}
}

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Las funciones: solonums_punto y solonums son utilizadas en la interfaz de contratos.
function solonums_punto(evt,obj)
{
/*Modificado - Carlos: Permite ingresar numeros decimales y sin signo, con un solo punto.*/
	var key = nav4 ? evt.which : evt.keyCode;
	var cad;
	var numero_puntos;//Determina el numero de puntos dentro del numero o cadena
	cad = obj.value;
	numero_puntos = cad.split(".").length;//Numero de Puntos para valor unitario.
 //El numero de puntos se determina con el nuevo punto que llega
	 numero_puntos = (key==46)?(1*numero_puntos+1):numero_puntos;
 //Hasta el momento esta llegando el dato para retornarlo al INPUT TEXT
	return (key <= 13 || (key >= 48 && key <= 57) ||(key==46 && numero_puntos<=2));
}

function solonums(evt)
{//Permite ingresar numeros sin signo y sin decimales
	var key = nav4 ? evt.which : evt.keyCode;
	return (key <= 13 || (key >= 48 && key <= 57));
}
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Funcion que detecta el navegador actual en el que se esta viendo el sistema.
function detectBrowser() {
    var ie = document.all != undefined;
    var opera = window.opera != undefined;
   
    if (opera) return "op";//Opera
    if (ie) return "ie";//Internet Explorer
    if ((window)&&(window.netscape)&&(window.netscape.security)) {
      if (window.XML) {
        return "fx";//Firefox
      }
      else return "fx";//Firefox
    }
    return "ie";      // Si no sabemos que navegador es, devolvemos ie.
}

//------------------------------------------------------------------------------
function display_element(id_element){//Cambia el atributo dysplay de un elemento luego de que haya pasado un tiempo
 document.getElementById(id_element).style.display = "none";
}

//------------------------------------------------------------------------------
function validar_vacio(campovalue){//Determinar si un campo esta vacio o no lo esta
    vacio   = campovalue.split(" ");
    num_vac = vacio.length;
    size    = num_vac - campovalue.length;
    return (size==1)?true:false;
    //Si esta vacio el campo retorna true, si tiene algun caracter retorna false
}
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/*
 Esta funcion la tomamos de la clase calendario de Tigra Calendar.. Retorna una cadena de caracteres con el error que ocurrio en la fecha.
*/
//Date Parsing Function: Funcion para el analisis de la fecha
var NUM_CENTYEAR = 30;
var RE_NUM = /^\-?\d+$/;
function analisis_fecha(str_date) {//Recibe como parametro una fecha con el siguiente formato: 2000-12-20
	var arr_date = str_date.split('-');

	if (arr_date.length != 3) return (text_fch[0] + str_date + text_fch[1]);
	if (!arr_date[0]) return (text_fch[0] + str_date + text_fch[2]);
	if (!RE_NUM.exec(arr_date[0])) return (text_fch[3] + arr_date[0] + text_fch[4]);
	if (!arr_date[1]) return (text_fch[0] + str_date + text_fch[5]);
	if (!RE_NUM.exec(arr_date[1])) return (text_fch[6] + arr_date[1] + text_fch[4]);
	if (!arr_date[2]) return (text_fch[0] + str_date + text_fch[7]);
	if (!RE_NUM.exec(arr_date[2])) return (text_fch[8] + arr_date[2] + text_fch[4]);

	var dt_date = new Date();
	dt_date.setDate(1);

	if (arr_date[1] < 1 || arr_date[1] > 12) return (text_fch[6] + arr_date[1] + text_fch[9]);
	dt_date.setMonth(arr_date[1]-1);
	 
	if (arr_date[2] < 100) arr_date[2] = Number(arr_date[2]) + (arr_date[2] < NUM_CENTYEAR ? 2000 : 1900);
	dt_date.setFullYear(arr_date[2]);

	var dt_numdays = new Date(arr_date[2], arr_date[1], 0);
	dt_date.setDate(arr_date[0]);
	if (dt_date.getMonth() != (arr_date[1]-1)) return (text_fch[3] + arr_date[0] + text_fch[10] +dt_numdays.getDate()+".");

	return true;//La fecha cumple con el formato y no tiene ningun error
}
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

function evaluar(a1,a2){//Fecha inicial - Fecha final
 resta=a2-a1;
 if(resta==0){
  x="2";
  return x;
 }
 if(resta<0){
  x="1";
  return x;
 }
 if(resta>0){
  x="0";
  return x;
 }
}
//------------------------------------------------------------------------------
//Esta variable global determina si la fecha inicial es mayor, menor o igual a la fecha final...
var valor;

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Pruebas Fechas
var f1;
var f2;
f1 = "01-11-2006";
f2 = "02-11-2006";
var result;
result = fecha1_mayor_fecha2(f1,f2);
alert(result);
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
function fecha1_mayor_fecha2(fecha1,fecha2){//dia-mes-ano: fecha1 = Fecha Inicial - fecha2 = Fecha Final
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Esta funcion devuelve TRUE si por lo menos fecha1 <= fecha2 de lo contrario devuelve FALSE
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
var ar1;var ar2;var i;
 ar1 = fecha1.split("-");
 ar1.reverse();
 ar2 = fecha2.split("-");
 ar2.reverse();
 var ano;
 var mes;
 var dia;
 valor = "";
 ano="";
 mes="";
 dia="";
 for(i=0;i<=2;i++){
    switch(i){
    case 0://ano
	 ano=evaluar(ar1[i],ar2[i]);
    break;
    case 1://mes
     mes=evaluar(ar1[i],ar2[i]);
    break
    case 2://dia
     dia=evaluar(ar1[i],ar2[i]);
    break
   }//switch.
 }//for.
 
 valor=ano+mes+dia;
  switch(valor){
/*La variable valor almacena lo siguiente: eplo: 000 primer digito ano, segundo digito mes, tercer digito dia. (0:mayor),(1:menor),(2:igual)*/
  case "000":
   return true;
  break;
  case "001":
   return true;
  break;
  case "002":
   return true;
  break;
  case "010":
   return true;
  break;
  case "011":
   return true;
  break;
  case "012":
   return true;
  break;
  case "020":
   return true;
  break;
  case "021":
   return true;
  break;
  case "022":
   return true;
  break;
  case "200":
   return true;
  break;
  case "201":
   return true;
  break;
  case "202":
   return true;
  break;
  case "220":
   return true;
  break;
  case "222"://Posibilidad de que las fechas por lo menos sean iguales..
   //alert('la fecha '+fecha1+ ' es menor de '+ fecha2);
   return true;
  break;
  default://la fecha final es menor que la fecha inicial
   return false;
  break;
  }
}//funcion
//------------------------------------------------------------------------------
function ventana_emergente(archivo, opcion_datos){
/*----------------------------------------------------------------------------*/
/*
 - Abre una ventana emergente con los datos que recibe esta funcion y los pasa 
   como metodo GET
*/
var parametros = 
"toolbar=no,location=no,directories=no,status=no,menubar=no,"+
"scrollbars=no,resizable=YES,copyhistory=no,width=700,height=500";
/*----------------------------------------------------------------------------*/
//Estos son los datos que se le envian al servidor en donde se creara el archivo XLS
switch(opcion_datos){
 case 0://Con esta opcion se crea el archivo que contiene las contrasenas de los administradores de las facultades
  //generar_archivo.php
  archivo = archivo +"?archivo=0";
 break;
 case 1:
  archivo = archivo +"?archivo=1";
 break;
}
/*----------------------------------------------------------------------------*/
open(archivo,'',''+parametros+'');
/*----------------------------------------------------------------------------*/
}
/*----------------------------------------------------------------------------
  La funcion comillas(), se creo para validar los datos que se van a ingresar al sistema, 
  con el fin de que no tengan ningun tipo de comillas, tanto para numeros como para cadenas 
  de caracteres.
----------------------------------------------------------------------------*/
function comillas(string)//Recibe como parametro una cadena de caracteres
{//Retorna true si por lo menos encuentra una de las siguientes comillas: '" 
 var str;
 //var re = /('|"|,|<|>|;)/;//Comillas, comas, menor que, mayor que: Estos caracteres pueden generar muchos problemas..  
 var re = /('|"|<|>)/;//Comillas, comas, menor que, mayor que: Estos caracteres pueden generar muchos problemas..
 str = string;
 str = str.toString();
  if(!str.match(re)){
   //alert("false");
   return false;
  }
  else{
   //alert("true");
   return true;
  }
}
/*----------------------------------------------------------------------------*/ 
 
function validar_caracteres(cadena){//Retorna FALSE si cadena es numérico o tiene comillas
 if(comillas(cadena)){//Retorna False, ya que tiene comillas.
  return false;	
 }
 if(!isNaN(cadena) || validar_vacio(cadena)){//isNaN(cadena): 
  return false;
 }
 else
  return true;
}

function isNumberFormat(elem, tipo){//Determina si una cadena es numerica y cumple con el formato, Retorna TRUE, de lo contrario retorna FALSE si tiene comillas o es una cadena
var str = elem.value;
	switch(tipo){
	 case 1: //Numeros positivos con decimales
	  //var re = /^(([0-9]+)|(([0-9]+)(([.])[0-9]+)*))$/;
	  var re = /^(([0-9]+)|(([0-9]+)(.)([0-9]+)*))$/;//Con un unico punto en el numero decimal
	 break;
	 case 2: //Numeros positivos sin decimales
	  //var re = /^(([0-9]+)((((,[0-9]+)?)*)|(([-][0-9]+)?)))$/;//Multiples Numeros positivos separados por comas o 2 numeros positivos separados por -
      var re = /^(([0-9]+))$/;
	 break;
	}
   
   if(comillas(str)){//Retorna False, ya que tiene comillas.
    return false;	
   }
   
   str = str.toString();
   if(!str.match(re)){
    return false;
   }
 return true;
}
//------------------------------------------------------------------------------
function NumberFormat(valor, tipo){//Determina si una cadena es numerica y cumple con el formato, Retorna TRUE
var str = valor;
	switch(tipo){
	 case 1: //Numeros positivos con decimales
	  var re = /^(([0-9]+)|(([0-9]+)(([.])[0-9]+)*))$/;
	 break;
	 case 2: //Numeros positivos sin decimales
		//var re = /^(([0-9]+)((((,[0-9]+)?)*)|(([-][0-9]+)?)))$/;//Multiples Numeros positivos separados por comas o 2 numeros positivos separados por -
      var re = /^(([0-9]+))$/;
	 break;
	}
   
   if(comillas(str)){//Retorna False, ya que tiene comillas.
    return false;	
   }
	str = str.toString();
   if(!str.match(re)){
    return false;
   }
 return true;
}
//------------------------------------------------------------------------------

function tipo_caracter(obj){//Retorna False si la cadena tiene comillas o si es un dato de tipo numerico 
//Determina si un campo es de tipo caracter: Devuelve TRUE si es una cadena de caracteres: Entre [A-Z, a-z, á-ú, Á-Ú]
  var text = new Array();
  var men;men="";
  text=obj;text=text.split(" ");
   for(i=0;i<text.length;i++){
     if(text[i]!=""){men+=text[i];}
   }
   
   if(comillas(obj)){//Retorna False, ya que tiene comillas.
   	return false;	
   }

   if(isNaN(men)==false){//Es numerico
     return false;
   }

   else {//No es numerico, devuelve true ya que es una cadena de caracteres
	 return true;
   } 
}


function tipo_alfanumerico(obj){//Retorna False si no es una cadena de caracteres o tiene comillas.
 //Expresion regular para alfanumericos y espacios en blanco
 if(comillas(obj)){//Retorna False, ya que tiene comillas.
  return false;	
 }
 var exp_reg =/(^\w)((((\w)|(\s))*)$)/;  
 if (obj.match(exp_reg))  
   return true;
 else
   return false;	
}
//------------------------------------------------------------------------------
function tipo_alfa(obj){//Retorna False si no es una cadena o tiene comillas
 if(comillas(obj)){//Retorna False, ya que tiene comillas.
  return false;	
 }
 var exp_reg =/([(a-z)(A-Z)(á-ú)])+/
  if (obj.match(exp_reg)) 
   return true;
  else 
    return false;
}

function isEMailAddr(elem){//Valida si se ha digitado un e-mail correctamente. Utilizando expreciones regulares
//Retorna TRUE si el mail digitado esta correcto.
  var str = elem.value;
  var re = /^[\w-]+(\.[\w-]+)*@([\w-]+\.)+[a-zA-Z]{2,7}$/;//Exprecion Regular
  if (!str.match(re)){return false;} 
   else{return true;}
}

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Calcula la resta entre dos horas y determina cual es mayor. 
 El formato de la hora es 10:11:12 y va desde las 00:00:00 hasta las 24:00:00
 Funciones: resta_horas_ - padNmb - stringToSeconds - secondsToTime - substractTimes
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
function resta_horas_(hora_inicio, hora_final){
  var resultado_resta;
  resultado_resta = substractTimes(hora_final, hora_inicio);
  alert(resultado_resta);
  return resultado_resta;
}

function padNmb(nStr, nLen){
	var sRes = String(nStr);
	var sCeros = "0000000000";
	return sCeros.substr(0, nLen - sRes.length) + sRes;
}

function stringToSeconds(tiempo){
	var sep1 = tiempo.indexOf(":");
	var sep2 = tiempo.lastIndexOf(":");
	var hor = tiempo.substr(0, sep1);
	var min = tiempo.substr(sep1 + 1, sep2 - sep1 - 1);
	var sec = tiempo.substr(sep2 + 1);
	return (Number(sec) + (Number(min) * 60) + (Number(hor) * 3600));
}

function secondsToTime(secs){
	var hor = Math.floor(secs / 3600);
	var min = Math.floor((secs - (hor * 3600)) / 60);
	var sec = secs - (hor * 3600) - (min * 60);
	return padNmb(hor, 2) + ":" + padNmb(min, 2) + ":" + padNmb(sec, 2);
}

function substractTimes(t1, t2){
	var secs1 = stringToSeconds(t1);
	var secs2 = stringToSeconds(t2);
	var secsDif = secs1 - secs2;
	return secondsToTime(secsDif);
}

/*--------------------------------- FUNCIONES PARA VALIDAR FECHAS ---------------------------------*/

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

function valSep(oTxt){
 var bOk = false;
 bOk = bOk || ((oTxt.value.charAt(4) == "-") && (oTxt.value.charAt(7) == "-"));
 bOk = bOk || ((oTxt.value.charAt(4) == "/") && (oTxt.value.charAt(7) == "/"));
 return bOk;
}
function finMes(oTxt){
 var nMes = parseInt(oTxt.value.substr(5, 7), 10);//obtengo el mes
 var nRes = 0;
 switch (nMes){
  case 1: nRes = 31; break;
  case 2: nRes = 28; break;
  case 3: nRes = 31; break;
  case 4: nRes = 30; break;
  case 5: nRes = 31; break;
  case 6: nRes = 30; break;
  case 7: nRes = 31; break;
  case 8: nRes = 31; break;
  case 9: nRes = 30; break;
  case 10: nRes = 31; break;
  case 11: nRes = 30; break;
  case 12: nRes = 31; break;
 }
 return nRes;
}

function valDia(oTxt){
 var bOk = false;
 var nDia = parseInt(oTxt.value.substr(8, 10), 10);//obtiene el dia
 bOk = bOk || ((nDia >= 1) && (nDia <= finMes(oTxt)));//valida que el dia seleccionado está dentro del limite de dias del mes
 return bOk;
}

function valMes(oTxt){
 var bOk = false;
 var nMes = parseInt(oTxt.value.substr(5, 7), 10);//obtiene el mes
 bOk = bOk || ((nMes >= 1) && (nMes <= 12));//verifica que el mes esté entre 1 y 12.
 return bOk;
}

function valAno(oTxt){
 var bOk = true;
 var nAno = oTxt.value.substr(0,4);//obtiene el año de la fecha.
 bOk = bOk && ((nAno.length == 2) || (nAno.length == 4));
 if (bOk){
  for (var i = 0; i < nAno.length; i++){
   bOk = bOk && esDigito(nAno.charAt(i));//valida que el año sea numerico, que no contenga letras.
  }
}
 return bOk;
}

function valFecha(oTxt){
 var bOk = true;
 if (oTxt != ""){
  bOk = bOk && (valAno(oTxt));
  bOk = bOk && (valMes(oTxt));
  bOk = bOk && (valDia(oTxt));
  bOk = bOk && (valSep(oTxt));
  if (!bOk){
   alert("Fecha invalida");
   oTxt.value = "";
   oTxt.focus();
  }
   return bOk;
 }
}