//-----------------------------------------------------------
//-- Definimos el prototipo del método para el objeto String

//-----------------------------------------------------------
String.prototype.Trim = String_trim;

// ----------------------------------------------------------------------
// Función : validacionAlfaNum
// Descripción : Comprueba que en el texto sólo hay letras sin acentuar,
// los caracteres extendidos (ñÑçÇ) o dígitos
// Parámetros : Cadena con el texto a analizar
// Retorno : false / true
// Notas : -
// ----------------------------------------------------------------------
function validacionAlfaNum( cTexto ) {
	// Recorremos los datos introducidos
	for ( nPos = 0; nPos < cTexto.length; nPos++ ) {
		var cCaracter = cTexto.charAt( nPos );
		if ( !( (cCaracter >= '0' && cCaracter <= '9') ||
				(cCaracter >= 'a' && cCaracter <= 'z') ||
				(cCaracter >= 'A' && cCaracter <= 'Z') ||
				(cCaracter == 'ñ' || cCaracter == 'Ñ'  ||
				 cCaracter == 'ç' || cCaracter == 'Ç') ) ) {
			return false;
		}
	}
	return true;
}

// ----------------------------------------------------------------------
// Función : validacionNumerico
// Descripción : Comprobación básica de que todos los caracteres de la
// cadena son sólo uno de estos "0123456789+-.,() "
// Parámetros : Cadena con en número a comprobar
// Retorno : false / true
// Notas : -
// ----------------------------------------------------------------------
function validacionNumerico( cNumero ) {
	// Recorremos los datos introducidos
	for ( nPos = 0; nPos < cNumero.length; nPos++ ) {
		var cCaracter = cNumero.charAt( nPos )
		if ( isNaN( parseInt( cCaracter ) ) 
		     && cCaracter != "-"
		     && cCaracter != "+"
		     && cCaracter != "."
		     && cCaracter != ","
		     && cCaracter != "("
		     && cCaracter != ")"
		     && cCaracter != " " ) {
			return false;
		}
	}
	return true;
}

// ----------------------------------------------------------------------
// Función : controlNumCaracteres
// Descripción : Control del máximo número de caracteres en un Textarea
// Parámetros : maxNumCaracteres,nameTextArea, nameFormulario, nameCapa
// maxNumCaracteres : Máximo número de caracteres permitidos en el TextArea
// nameTextArea : Name del TextArea
// nameFormulario : Name del Formulario
// nameCapa : Name de la Capa
// Retorno : false / true
// Notas : Si el formulario no tiene capas el parámetro nameCapa no será
// necesario
// ----------------------------------------------------------------------
function controlNumCaracteres(maxNumCaracteres,nameTextArea, nameFormulario, nameCapa, nameCapa2)
{
	var form_div = "";
	if (navigator.appName == 'Netscape' && nameCapa != null && nameCapa2 != null)
	{
		// netscape
		form_div = 'document.layers["' + nameCapa + '"].document.layers["' + nameCapa2 + '"].document.' + nameFormulario;
	}
	else if (navigator.appName == 'Netscape' && nameCapa != null && nameCapa2 == null)
	{
		// netscape
		form_div = 'document.layers["' + nameCapa + '"].document.' + nameFormulario;
	}
	else 
	{
		// explorer
		form_div = 'document.' + nameFormulario;
	}
	if (eval(form_div + '.' + nameTextArea + '.value.length') > maxNumCaracteres)
	{
		alert("El máximo número de caracteres permitidos es " + maxNumCaracteres);	
		eval (form_div + '.' + nameTextArea + '.focus');
		return false;
	}
	else {
		return true;
	}					
}

// ----------------------------------------------------------------------
// Función : validacionFechaSlash
// Descripción : Comprobación básica de que todos los caracteres de la
// cadena son sólo uno de estos "0123456789/ "
// Parámetros : Cadena con en número a comprobar
// Retorno : false / true
// Notas : -
// ----------------------------------------------------------------------
function validacionFechaSlash( cFecha ) {
	// Recorremos los datos introducidos
	for ( nPos = 0; nPos < cFecha.length; nPos++ ) {
		var cCaracter = cFecha.charAt( nPos )
		if ( isNaN( parseInt( cCaracter ) ) 
		     && cCaracter != "/") 
		{
			return false;
		}
	}
	return true;
}
// ----------------------------------------------------------------------
//
// Función : validacionMail()
// Descripción : Comprueba que una determinada cadena tiene formato de
// dirección de correo electrónico
// Parámetros : cMail - Cadena a comprobar
// Retorno : true / false
// Ejemplo : <input type="text" onBlur="return CheckMail( this.value )">
//
// ----------------------------------------------------------------------

function validacionMail( cMail ) {
	// Eliminar los blancos por delante y por detrás
	// cMail = cMail.Trim();
	// Comprobar que se tiene una arroba y esta no está al principio
	var nPos1 = cMail.indexOf("@");
	if ( nPos1 < 1 ){
		return false;
	}

	// Comprobar que se termina con un dominio
	var nPos2 = cMail.lastIndexOf(".");
	if (   nPos2 < nPos1 
		|| nPos2 == nPos1+1 
		|| (nPos2 + 3 > cMail.length) ) {		
		return false;
	}	
	
	// Comprobar que no contiene blancos entre medias
	if ( cMail.indexOf( " " ) != -1 ) {
		return false
	}

	// El formato parece correcto
	return true;
}

// ----------------------------------------------------------------------
//
// Función : validacionDigito
// Descripción : Comprobación básica de que todos los caracteres de la
// cadena son sólo uno de estos "0123456789"
// Parámetros : Cadena con en número a comprobar
// Retorno : false / true
// Notas : -
//
// ----------------------------------------------------------------------
function validacionDigito( cNumero ) {
	// Recorremos los datos introducidos
	for ( nPos = 0; nPos < cNumero.length; nPos++ ) {
		var cCaracter = cNumero.charAt( nPos )
		if ( isNaN( parseInt( cCaracter ) ) ) {
			return false;
		}
	}
	return true;
}

// ----------------------------------------------------------------------
// Función : validacionFormatoNumero
// Descripción : Comprobación básica de que todos los caracteres de la
// cadena son sólo uno de estos "0123456789 ," además sólo tiene que tener una
// coma
// Parámetros : Cadena con el número a comprobar
// Retorno : false / true
// Notas : -
// ----------------------------------------------------------------------
function validacionFormatoNumero( cNumero ) {
	// Recorremos los datos introducidos
	var numComas = 0;
	for ( nPos = 0; nPos < cNumero.length; nPos++ ) {
		var cCaracter = cNumero.charAt( nPos );
		if ( isNaN( parseInt( cCaracter ) ) && cCaracter != "," ) {
			return false;
		}
		if (cCaracter == "," ) {
			numComas ++;
			if (numComas > 1){
				return false;
			}	
		}

	}
	return true;
}

// ----------------------------------------------------------------------
//
// Función : validacionFecha
// Descripción : Realiza la validación de un dato tipo fecha
// Parámetros : Cadena con la fecha a trasformar
// Retorno : true / false
// Notas : - Admite los formatos de entrada siguientes:
// d/m/yy
// dd/mm/yy
// dd/mm/yyyy
// - En el caso de incluir solo dos dígitos para el año,
// se interpreta como fecha del año 2000 los inferiores
// o igual a 30.
//
// ----------------------------------------------------------------------
function validacionFecha( cFecha ) {

	// Comprobación de tamaño
	if ( cFecha.length < 6 || cFecha.length > 10 ) { 
		return false;
	}
	
	if (cFecha.length == 6)
	{
		if (!validacionNumerico(cFecha.substring(0,1)))
		{
			return false;
		}
		if (!validacionNumerico(cFecha.substring(2,3)))
		{
			return false;
		}
		if (!validacionNumerico(cFecha.substring(4)))
		{
			return false;
		}
	}
	
	if ((cFecha.length == 8) || (cFecha.length == 10))
	{
		if (!validacionNumerico(cFecha.substring(0,2)))
		{
			return false;
		}
		if (!validacionNumerico(cFecha.substring(3,5)))
		{
			return false;
		}
		if (!validacionNumerico(cFecha.substring(6)))
		{
			return false;
		}
	}
	// Buscar primer separador de la fecha
	var nSeparador1 = cFecha.indexOf( "/", 0 )
	if ( nSeparador1 < 1 || nSeparador1 > 2 ) {
		return false;
	}
	
	// Obtener el día
	var cDia = cFecha.substring(0, nSeparador1)
	
	// Buscar el segundo separador de la fecha
	var nSeparador2 = cFecha.indexOf( "/", nSeparador1+1 )
	if ( nSeparador2 < nSeparador1+2 || nSeparador2 > nSeparador1+3 ) {
		return false;
	}
	
	// Obtener el mes
	var cMes = cFecha.substring(nSeparador1+1, nSeparador2)
	
	// Obtener el año
	var cYear = cFecha.substring(nSeparador2+1, cFecha.length)

	// Normalización del año
	if ( cYear.length == 1 || cYear.length == 3 ) {
		return false;
	}
	// ¡¡¡¡--Cuidado con la funcionalidad de esto para nacimientos anteriores a
	// 1929.---!!!!
	if ( cYear.length == 2 ) {
		if ( parseInt( cYear ) > 29 ) {
			cYear = "19" + cYear
		} else {
			cYear = "20" + cYear
		}
	}

	// Comprobación del mes
	if ( cMes < 1 || cMes >12 ) {
		return false;
	}
	
	// Comprobación básica del día
	if ( cDia < 1 || cDia >31) {
		return false;
	}
	
	// Comprobación del día en los meses con 30 días
	if ( (cMes==4 || cMes==6 || cMes==9 || cMes==11) && (cDia == 31 ) ) {
		return false;
	}
	
	// Comprobación del mes de febrero teniendo en cuenta los bisiestos
	if ( cMes==2 ){
		if ( cDia > 29 ) {
			return "";
		}
		if ( ( cYear / 4 == parseInt( cYear / 4 ) )  
		     && ! ( ( cYear / 100 == parseInt( cYear / 100 ) ) 
                         && ( cYear / 400 != parseInt( cYear / 400 ) ) ) ) {
			var bBisiesto = true;
		} else {
			var bBisiesto = false;
		}
		if ( ! bBisiesto && cDia==29 ) {
			return false;
		}
	}
	
	// Retorno Ok
	return true;
	
}
 
function formatoDDMMYYYY( cFecha )
{
	// Buscar primer separador de la fecha
	var nSeparador1 = cFecha.indexOf( "/", 0 );
	// Obtener el día
	var cDia = cFecha.substring(0, nSeparador1);
	if(cDia.length==1)
	{
		cDia = "0" + cDia;
	}
	// Buscar el segundo separador de la fecha
	var nSeparador2 = cFecha.indexOf( "/", nSeparador1+1 );
	// Obtener el mes
	var cMes = cFecha.substring(nSeparador1+1, nSeparador2);
	if(cMes.length==1)
	{
		cMes = "0" + cMes;
	}
	// Obtener el año
	var cYear = cFecha.substring(nSeparador2+1, cFecha.length)
	if(cYear.length==2)
	{
		cYear = "20" + cYear;
	}
	var sFechaValida = cDia + "/" + cMes + "/" + cYear;
	return sFechaValida;
}
// ----------------------------------------------------------------------
//
// Función : CheckModificar
// Descripción : Comprobación básica de que todos los caracteres de la
// cadena son validos.
// Parámetros : Cadena con en texto a comprobar
// Retorno : false / true
// Notas : -
//
// ----------------------------------------------------------------------
function CheckModificar( cTexto ) 
{
	// Recorremos los datos introducidos
	for ( nPos = 0; nPos < cTexto.length; nPos++ ) 
	{
		var cCaracter = cTexto.charAt( nPos )
	
		if ( 
				cCaracter == "-"
		     || cCaracter == "+"
		     || cCaracter == '#'
		     || cCaracter == '&'
		     || cCaracter == '%'
		     || cCaracter == '"'
		     || cCaracter == "'"
		     || cCaracter == "."
		     || cCaracter == ","
		     || cCaracter == "("
		     || cCaracter == ")"
			 || cCaracter == 'ç' 
			 || cCaracter == 'Ç' )
		{
			return false;
		}
	}
	
	return true;
}

// ----------------------------------------------------------------------
// Método : Trim
// Descripción : Añade un método Trim al objeto String de JavaScript
// para eliminar blancos por delante y por detrás de una
// cadena
// Parámetros : -
// Retorno : Cadena sin espacios por delante y por detras del texto
// Notas : -
// ----------------------------------------------------------------------

function String_trim(Cadena)
{
	// Recorremos los datos introducidos
	var lon;
	var p1;
	var p2;
	var c;
	var buffer;
	
	lon=Cadena.length;
	p1=0;
	c=Cadena.charAt(p1);
	
	while (p1<=lon-1 && c==" ")
	{
		p1++;
		c=Cadena.charAt(p1);
	}
	
	p2=lon;
	c=Cadena.charAt(p2-1);
	
	while (p2>=0 && c==" ")
	{
		p2--;
		c=Cadena.charAt(p2-1);
	}

	if (p1>=p2) 
		buffer="";
	  else
	    buffer=Cadena.substr(p1,p2-p1);	

	return buffer;
}

// ----------------------------------------------------------------------
// Función : validaCheckPulsado
// Descripción : Valida si de los checkbox de un formulario hay alguno
// pulsado antes de enviar el formulario
// Parámetros : El nombre del formulario
// Retorno : true / false
// Notas : Solo se utilizará si es obligatorio que se seleccione
// algún ckeckbox
// ----------------------------------------------------------------------
function validaCheckPulsado(cNombreFormulario)
{
	
	var iNumElem=0;
	
	for (i=0;i<eval("document." + cNombreFormulario + ".length");i++)
	{
			if(eval("document." + cNombreFormulario + "[i].type=='checkbox'") && eval("document." + cNombreFormulario + "[i].checked==true")) 
			{
				iNumElem++;	
			}
	}
	if (iNumElem!=0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

// ----------------------------------------------------------------------
// Función : validaOptionPulsado
// Descripción : Valida si de los option de un formulario hay alguno
// pulsado antes de enviar el formulario
// Parámetros : El nombre del formulario
// Retorno : true / false
// Notas : Solo se utilizará si es obligatorio que se seleccione
// algún radioButton
// ----------------------------------------------------------------------
function validaOptionPulsado(cNombreFormulario)
{
	
	var iNumElem=0;
	for (i=0;i<eval("document." + cNombreFormulario + ".length");i++)
	{
			if(eval("document." + cNombreFormulario + "[i].type=='radio'") && eval("document." + cNombreFormulario + "[i].checked==true")) 
			{
				iNumElem++;	
			}
	}
	
	if (iNumElem!=0)
	{
		return true;
	}
	else
	{
		return false;
	}
}
// ----------------------------------------------------------------------
// Función : validaOptionConcretoPulsado
// Descripción : Valida si alguna de las opciones de un option está pulsada
// Parámetros : El nombre del formulario, el nombre del radioButton
// Retorno : true / false
// Notas : Solo se utilizará si es obligatorio que se seleccione
// algún radioButton
// ----------------------------------------------------------------------
function validaOptionConcretoPulsado(cNombreFormulario, cNombreOption)
{
	val = (eval("document." + cNombreFormulario + "." + cNombreOption + ".length"));
	for (i=0; i<val; i++){
		if(eval("document." + cNombreFormulario + "." + cNombreOption + "[i].checked==true")) {
			return true;
		}
	}
	return false;
	
}

// ----------------------------------------------------------------------
// Función : validaCampoObligatorio
// Descripción : Valida si en un campo obligatorio de un formulario
// se ha introducido algún valor y no son blancos.
// Parámetros : El nombre del formulario y el nombre del campo (String)
// Retorno : true / false
// Notas : Solo se utilizará si es obligatorio que se rellene
// el campo texto
// ----------------------------------------------------------------------
function validaCampoObligatorio(cNombreFormulario,cTexto)
{
	var texto=String_trim(eval("document." + cNombreFormulario + "." + cTexto + ".value"));
	
	if(texto!='')
	{ 
		return true;
	}
	else
	{
		return false;
	}
}

// ----------------------------------------------------------------------
// Función : validaSelectObligatorio
// Descripción : Valida si en un Select del formulario, se ha cambiado su
// valor, o por el contrario se ha dejado el valor que tiene
// por defecto.
// Parámetros : El nombre del formulario y el nombre del Select (String)
// Retorno : true / false
// Notas : Solo se utilizará si es obligatorio que se le asigne un
// valor al campo Select.
// ----------------------------------------------------------------------
function validaSelectObligatorio(cNombreFormulario,cNombre)
{
	return( eval("document." + cNombreFormulario + "." + cNombre + ".options[document." + cNombreFormulario + "." + cNombre + ".selectedIndex].defaultSelected"));
}



function longitudCadena(cadena,longitud)
{
	longitudComentario = cadena.length;
	

	if (longitudComentario > longitud)
	{
		return true;	
	}
	else
	{
		return false;
	}
}

/*
 * ---------------------- FUNCIÓN : mesesDiferencia ********** DESCRIPCIÓN :
 * devuelve los meses (naturales) de diferencia que hay entre dos fechas:
 * 18/09/01 PARÁMETROS : param (String, String) : fecha de inicio y fin del tipo
 * ---> DDMMAAAA
 * 
 * VALOR RETORNO : String : Cantidad de meses de diferencia, (aprox).
 * 
 * NOTA : La fecha de inicio debe ser menor que la final.
 * ---------------------------
 */	

function mesesDiferencia(sFechaInicio, sFechaFin)
{
	var diaInicio, diaFin, mesInicio, mesFin, yearInicio, yearFin, yearTotal, mesTotal, diaTotal;

	diaInicio = parseInt(sFechaInicio.substring(0,2),10);
	mesInicio = parseInt(sFechaInicio.substring(2,4),10);
	yearInicio = parseInt(sFechaInicio.substring(4),10);

	diaFin = parseInt(sFechaFin.substring(0,2),10);
	mesFin = parseInt(sFechaFin.substring(2,4),10);
	yearFin = parseInt(sFechaFin.substring(4),10);

	// Para los años:
	yearTotal = yearFin - yearInicio;

	if(yearTotal < 0)
	{
		// Error, la fecha final no puede ser menor que la inicial.
		return yearTotal;
	}

	// Para los meses:
	mesTotal = mesFin - mesInicio;

	if(mesTotal < 0)
	{
		yearTotal -= 1;
		mesTotal += 12;
	}

	mesTotal += yearTotal * 12;		
	
	// Para los días:
	diaTotal = diaFin - diaInicio;
	if(diaTotal < 0)
	{
		mesTotal -= 1;
		diaTotal += 30;
	}

	mesTotal += diaTotal/30;

}

// Selecciona la opción del combo que coincide con el texto pasado.
function seleccionarComboTexto(combo, texto){
    var i = 0;
    var ok = "true";
    while ((i < combo.length) && (ok == "true" )) {
       if (combo[i].text == texto) {
          combo.selectedIndex = i;
          ok = "false";
          break;
       } 
       else 
           i++;
    }
}