function abreVentana() {
var especificaciones="top=0, left=0, toolbar=no,location=no, status=no,menubar=no,scrollbars=no, resizable=no, width=620, height=440"
var titulo="Suscribete a nuestro periodico"
window.open('suscripcion.php','_blank',especificaciones);
}

function include(file_path){
	var j = document.createElement("script");
	j.type = "text/javascript";
	j.src = file_path;
	document.body.appendChild(j);
}


// ENVIO POST
function sendRequest(formulario, marco) {
            if(marco==""){marco="visor";}
			var oForm = formulario;
            var sBody = getRequestBody(oForm);
            var oXmlHttp = zXmlHttp.createRequest();
            oXmlHttp.open("post", oForm.action, true);
            oXmlHttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
            
            oXmlHttp.onreadystatechange = function () {
                if (oXmlHttp.readyState == 4) {
                    if (oXmlHttp.status == 200) {
                        saveResult(oXmlHttp.responseText, marco);
                    } else {
                        saveResult("Error: " + oXmlHttp.statusText, marco);
                    }
                }            
            };
            oXmlHttp.send(sBody);        
        }
		
//ENVIO GET

// ENVIO GET
function  contenidos(direccion,marco){           	
			var oXmlHttp = zXmlHttp.createRequest();
			var marco_busqueda = document.getElementById('cargando_c');
			oXmlHttp.open("get", direccion+"?marco="+marco, true);
			oXmlHttp.onreadystatechange = function () {
				if (oXmlHttp.readyState == 1) {
					marco_busqueda.innerHTML="Cargando...";
				}
				if (oXmlHttp.readyState == 4) {
					if (oXmlHttp.status == 200) {
						marco_busqueda.innerHTML="";
						displayCustomerInfo(oXmlHttp.responseText, marco); //llama a la funcion js de mas abajo y pasa los datos a el div
					} else {
						displayCustomerInfo("An error occurred: " + oXmlHttp.statusText, marco); //statusText is not always accurate
					}
				}            
			};
			oXmlHttp.send(null);
			
}

function  busqueda(buscar){           	
			var oXmlHttp = zXmlHttp.createRequest();
			oXmlHttp.open("get", "resultado.php?buscar="+encodeURIComponent(buscar), true);
			 var marco_busqueda = document.getElementById('cargando');
            
			oXmlHttp.onreadystatechange = function () {
				if (oXmlHttp.readyState == 1) {
					marco_busqueda.innerHTML="Cargando...";
				}
				if (oXmlHttp.readyState == 4) {
					if (oXmlHttp.status == 200) {
						marco_busqueda.innerHTML="";
						displayCustomerInfo(oXmlHttp.responseText, 'busqueda'); //llama a la funcion js de mas abajo y pasa los datos a el div
					} else {
						displayCustomerInfo("An error occurred: " + oXmlHttp.statusText, 'busqueda'); //statusText is not always accurate
					}
				}            
			};
			oXmlHttp.send(null);
			
}
function displayCustomerInfo(sText, marco) {
            var divCustomerInfo = document.getElementById(marco);
            divCustomerInfo.innerHTML=sText;
			return true;
}

function vaciaMarco(marco){
	var divCustomerInfo = document.getElementById(marco);
	var escribe='';
	var dime= getCookie('busqueda');
	if(marco =='busqueda' && dime !=""){ escribe=' <a href="#" onclick="saca()" class="relac">Click aqu&iacute; para recuperar la &uacute;ltima b&uacute;squeda...</a>'; }
	divCustomerInfo.innerHTML = escribe;
}
//envio con imagen
function getRequestBody(oForm) {
            var aParams = new Array();
            
            for (var i=0 ; i < oForm.elements.length; i++) {
                var sParam = encodeURIComponent(oForm.elements[i].name);
					if (sParam=="texto"){ //arreglo para que fsckeditor funcione con ajax
                		sParam += "=";
						sParam += escape(FCKeditorAPI.GetInstance('texto').GetXHTML());
					}else{ 
						sParam += "=";
						sParam += encodeURIComponent(oForm.elements[i].value);
					}
			 
                aParams.push(sParam);
            } 
            
            return aParams.join("&");        
}
  
        
function saveResult(sMessage,marco) {
	//var datos= sMessage.split("||");
    var ver = document.getElementById(marco);
	ver.innerHTML = sMessage;
	
}

function enviar()
{
	if (validar(document.sus)) sendRequest(document.sus, "suscripcion");
}
function validar(frm)
{	
	if (!errorSiVacio(frm.Apellidos, 'Apellidos', true)) return false;
	if (!errorSiVacio(frm.Nombre, 'Nombre', true)) return false;
	if (!errorSiVacio(frm.Domicilio, 'Domicilio', true)) return false;
	if (!errorSiVacio(frm.Localidad, 'Localidad', true)) return false;
	if (!errorSiVacio(frm.provincia, 'Provincia', true)) return false;
	if (!errorSiVacio(frm.CP, 'Código Postal', true)) return false;
	if (!errorSiVacio(frm.cuenta, 'Numero de cuenta', true)) return false;
	if (!vCP(frm.CP, 0, false)) return false;
	
	//if (!vFecha(frm.FechaNa, 'Fecha Nacimiento', false)) return false;
	//if (!vEmail(frm.Email, 'E-mail', true)) return false;
	//if (!vTelefono(frm.Telefono1, 'Teléfono1', false)) return false;
	//if (!vTelefono(frm.Telefono2, 'Teléfono2', false)) return false;
	//if (!vTelefono(frm.Telefono3, 'Teléfono3', false)) return false;
	if (!frm.chkAcepto.checked)
	{
		alert('Debe aceptar las condiciones de la Ley Orgánica de Protección de Datos (LOPD)');
		return false;
	}	
	return true;
}

String.prototype.trim = function ()

{

	return this.lTrim().rTrim();

}



String.prototype.lTrim = function ()

{

	return this.replace(/(^\s+)/g, '');

}





String.prototype.rTrim = function ()

{

	return this.replace(/(\s+$)/g, '');

}



String.prototype.left = function (n)

{

	return this.substr(0, n);

}



String.prototype.right = function (n)

{

	return this.substr(this.length-n, n);

}



function errorSiVacio(campo, nombre)

{

	if (campo.value.trim() == '')

	{

		alert('El campo "' + nombre + '" no puede estar vacio. ');

		campo.focus();

		return false;

	}

	return true;

}
function vTextarea(campo, desc, maxLin, maxCar, requerido)

{

	var re, numLin;

	

	campo.value = campo.value.trim();

	

	if (campo.value == '') 

	{

	    if (requerido)

    	{

    		alert('El campo "'+ desc +'" no puede estar vacio.');

    		campo.focus();

    		return false;

    	}

    	else return true;

	}





  	if (maxCar!=null && campo.value.length>maxCar)

	{

		alert('El texto de '+desc+' no puede sobrepasar los '+maxCar+' caracteres.');

		campo.focus();

		return false;

	}



	if (maxLin!=null)

	{

		re = /(\r\n)*$/g;

		campo.value = campo.value.replace(re, '');

		re = /\n/g;

		numLin = campo.value.match(re);

		if (numLin.length >= maxLin)

		{

			alert('El texto de '+desc+' no puede tener más de '+ maxLin +' líneas.');

			campo.focus();

			return false;

		}

	}

	return true;

}
function esEmail(emailStr) {

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=emailStr.match(emailPat)

if (matchArray==null){return false}

var user=matchArray[1]

var domain=matchArray[2]

if (user.match(userPat)==null){return false}

var IPArray=domain.match(ipDomainPat)

if (IPArray!=null) {

	  for (var i=1;i<=4;i++) {

	    if (IPArray[i]>255) {return false}

    }

    return true

}

var domainArray=domain.match(domainPat)

if (domainArray==null) {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) {

   return false

}

if (len<2) {return false}

return true;

}



//-----------------------------------------------------------------------------

function vEmail (campo, desc, requerido)

{

	if (campo.value.trim() == '')

	{

		if (requerido)

		{

			alert('El campo "'+ desc +'" no puede estar vacio. ');

			campo.focus();

			return false;

		}

		else return true;

	}

	

	if (esEmail(campo.value)) return true;

	else

	{

		alert('El contenido del campo "' + desc + '" no es una dirección de correo válida. ');

		campo.focus();

		return false;

	}

}

/*-----------------------------------------------------------------------------

 Convierte una cadena en formato n.nnn,nn a nnnn.nn

-----------------------------------------------------------------------------*/

String.prototype.numToUSA= function ()

{

    var re = /\./g;

    var re2 = /,/g;

    return this.replace(re, '').replace(re2, '.');

}





/*-----------------------------------------------------------------------------

 Convierte una cadena en formato n,nnn.nn a nnnn,nn

-----------------------------------------------------------------------------*/

String.prototype.numToESP= function ()

{

	var re1 = /,/g;

    var re2 = /\./g;    

    return this.replace(re1,'').replace(re2,',');

}



//-----------------------------------------------------------------------------

function esNumero(valor, decimal)

{

    var re;



    if (decimal > 0)  re = new RegExp ("^[+-]?\\d{1,}(\\.?\\d{3,3})*(,\\d{1,"+ decimal +"})?$");

    else re = new RegExp ("^[+-]?\\d{1,}(\\.?\\d{3,3})*$");



    return re.test(valor);

}



//-----------------------------------------------------------------------------

function vNumero(campo, desc, min, max, dec, requerido)

{

    var error = false;

    var msg = ""



	campo.value = campo.value.trim();

	

	if (campo.value == '') 

	{

	    if (requerido)

    	{

    		alert('El campo "'+ desc +'" no puede estar vacio.');

    		campo.focus();

    		return false;

    	}

    	else return true;

	}



    

    if (esNumero(campo.value, dec))

    {

        if (min==null && max==null) return true;

        if (min!=null)

        {

            if (campo.value.numToUSA()<min) error=true;

        }

        if (max!=null)

        {

            if (campo.value.numToUSA()>max) error=true;

        }

    }

    else error = true;



    if (error)

    {

        msg = 'El contenido del campo "'+ desc + '" no es un número válido.\n';

        if (min!=null & max !=null) msg += "Debe estar comprendido entre "+ min +" y "+ max +"\n";

        else if (min!=null) msg += "No puede ser inferior a "+ min +"\n";

        else if (max!=null) msg += "No puede ser mayor de "+  max +"\n";

        if (dec!=null && dec>0) msg+="No puede contener más de "+ dec +" decimales (use la coma como separador)\n";

        else msg += "No puede tener decimales\n";

        if (min > 999 || max>999)  msg += "Puede usar el punto como separador de miles"



        alert(msg);

        campo.focus();

        return false;

    }

    return true;

}



/*-----------------------------------------------------------------------------*/





function vCP(campo, dec, requerido)

{ 

	campo.value = campo.value.trim();

	if (campo.value == '') 

	{

	    if (requerido)

    	{

    		alert('El campo Código Postal no puede estar vacio.');

    		campo.focus();

    		return false;

    	}

    	else return true;

	}

	if (campo.value.length < 5)

	{

		alert('El contenido del campo Código Postal no es válido');

		return false;

	}

 	if (!esNumero(campo.value, dec))

 	{

 		alert('El contenido del campo Código Postal no es válido');

 		return false;

 	}

	return true;

}



/*-----------------------------------------------------------------------------

 Devuelve una cadena con un número en el formato nn.nnn,nn

 - num: numero o cadena con formato nn,nnn.nn (las comas son opcionales)

 - nDec: número de dígitos de la parte decimal

 - rellenaDec: opcional. (true|false) completa la parte derecha de los

	decimales hasta completar "nDec" dígitos. Por defecto es "false"

-----------------------------------------------------------------------------*/

function formateaNum(num, nDec, rellenaDec)

{

    var numero = ''+num;

    var re1 = new RegExp ('(\\d+)(\\.\\d*)?$', 'g');

    var re2 = new RegExp ('(\\d+)(\\d{3,3})$', 'g');

    var salida ="";



    if (numero.substr(0,1)=='.') numero = '0'+numero;



    indice = numero.search(re1);

    entero = RegExp.$1;

    decimal = RegExp.$2;



    indice = entero.search(re2)



    while (indice != -1)

    {

        salida = '.' + RegExp.$2 + salida;

        entero = RegExp.$1;

        indice = entero.search(re2);

    }

    salida = entero+salida;



    if ( nDec != null && ((decimal!='' && decimal!='.') || rellenaDec))

    {

    	if (rellenaDec) decimal += '000000000000';

        salida += ',' + decimal.substr(1, nDec);

    }



    if (parseFloat(numero) < 0) return '-'+salida;

    else return salida;

}



function vImporte(campo, desc, decimales, requerido)

{

   if ((!requerido) && campo.value.trim() == "") return true;



    var re;

    if (decimales > 0)

    	re = new RegExp("^((\\d{1,})(\\.?\\d{3,3})*(\\,\\d{0,"+ decimales +"})?)$");        

    else

    	re = new RegExp("^(([0-9]{1,})(\\.?[0-9]{3,3})*)$");        



    if (re.test(campo.value)) return true;

    else

    {

        if (decimales > 0 )

            alert("El contenido del campo '" + desc + "' no es válido. " +

                "Introduzca solo números, use la coma como separador de decimales. "+

                "No puede introducir mas de "+ decimales + " decimales. "+

                "Si desear puede usar puntos como separador de millares.");

        else

            alert("El contenido del campo '" + desc + "' no es válido. " +

                "Introduzca solo números. Si desear puede usar puntos como separador de millares.");

        campo.focus();

        return false;

    }



}
/*---------------------------------------------------------------------------

 Los números internacionales tiene que estar precedidos por el carácter "+"

---------------------------------------------------------------------------*/

function esTelefono(campo)

{

  var re = new RegExp("^(([0-9]{9})|([+][0-9]{11}))$")



  return re.test(campo.value);

}





//---------------------------------------------------------------------------

function vTelefono (campo, desc, requerido)

{

	var cad;



	campo.value = campo.value.trim();

	

	if (campo.value == '') 

	{

	    if (requerido)

    	{

    		alert('El campo "'+ desc +'" no puede estar vacio.');

    		campo.focus();

    		return false;

    	}

    	else return true;

	}



	if (esTelefono(campo)) return true;

	else

	{

		cad = 'El contenido del campo "'+ desc +'" no es un teléfono válido.';

		if (campo.value.length==11) cad += '\nSi es un número internacional, prefíjelo con el carácter "+".';

		alert(cad);



		campo.focus();

		return false;

	}

}


/*-----------------------------------------------------------------------------

	Luis Miguel Santiago Piñeiro - v2.0 - Julio 2002

-----------------------------------------------------------------------------*/



/*-----------------------------------------------------------------------------

  Valida un campo que contiene una fecha en formato : dd-mm-aaaa o dd/mm/aaaa.

  Los días y meses pueden ser de un dígito.

  - fMin: Opcional. fecha mínima. Se omite si es blanco o null.

  - fMax: Opcional. fecha máxima. Se omite si es blanco o null.

  Elimina los espacios laterales del contenido del campo.

-----------------------------------------------------------------------------*/

function vFecha (campo, desc, requerido, fMin, fMax)

{

	var msg='', err=false;

	campo.value = campo.value.trim();

	

	if (campo.value == '')

	{

	    if (requerido)

    	{

    		alert('El campo "'+ desc +'" no puede estar vacio.');

    		campo.focus();

    		return false;

    	}

    	else return true;

    }

    if (!esFechaValida(campo.value)) err=true;

    else if (fMin!=null && fMin!='' && strToDate(campo.value)<strToDate(fMin)) err = true;

    else if (fMax!=null && fMax!='' && strToDate(campo.value)>strToDate(fMax)) err = true;

    if (err)

    {

    	msg = 'El contenido del campo "'+ desc +'" no es una fecha válida.\n'+

    	      'Por favor, introduzca la fecha con el formato "dd-mm-aaaa" o "dd/mm/aaaa".';

		if (fMin != null && fMin!='') msg += '\nNo puede ser inferior a "'+ fMin +'".';

		if (fMax != null && fMax!='') msg += '\nNo puede ser mayor que "'+ fMax +'".';

		alert(msg);

		campo.focus();

		return false;		

    }

    return true;

}



/*-----------------------------------------------------------------------------

  Devuelve una cadena con una fecha en un formato determinado.

  - oDate: objeto Date que contiene la fecha.

  - formato: formato a aplicar a la fecha. Los carácteres para formater la 

    fecha son:

  	- d, dd, ddd, dddd, DDD,DDDD: día. Ej: 1, 01, Lun, Lunes, LUN, LUNES

  	- m, mm, mmm, mmmm, MMM, MMMM: mes. Ej: 1, 01, Ene, Enero, ENE, ENERO

  	- aa, aaaa: año. Ej: 02, 2002

  	- h, hh: hora. Ej: 1, 01

  	- n, nn: minutos. Ej: 1, 01

  	- s, ss: segundos. Ej: 1, 01 	

  	- Si se quiere añadir al resulado un carácter de los anterios se debe

  	  preceder con el car. '/'. Se usa '//' para mostrar una barra simple.

  	- Si se quiere que aparezca una '\' se debe poner dos veces.  

  	- Cualquier otro carácter se añade a la cadena directamente.

  Ej: 'dddd, dd /de mmmm /de aaaa' => Martes, 01 de Enero de 2002	

      'dd//mm//aaaa' => 01/01/2002

-----------------------------------------------------------------------------*/

function dateToStr(oDate, formato)

{

    var re, s='', pos, tmp;

	if (oDate==null) return '';

	

	var re = /((d+)|(m+)|(a+)|(h+)|(n+)|(s+)|([^\/dmahns])|(\/[\/dmahns]?))/i;

		

	pos = formato.search(re);



	while(pos!=-1)

	{

		switch(RegExp.$1)

		{

			case 'd': s += oDate.getDate(); break;

			case 'dd': s += ('0'+oDate.getDate()).right(2); break;

			case 'ddd': 

			case 'DDD': 

				tmp = ['Dom', 'Lun','Mar', 'Mie', 'Jue', 'Vie', 'Sab'][oDate.getDay()]; 

				if (RegExp.$1 == 'DDD') tmp = tmp.toUpperCase();

				s += tmp;

				break;

			case 'dddd': 

			case 'DDDD': 

				tmp = ['Domingo', 'Lunes','Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado'][oDate.getDay()];

				if (RegExp.$1 == 'DDDD') tmp = tmp.toUpperCase();

				s += tmp;

				break;		

			case 'm':  s += oDate.getMonth()+1; break;

			case 'mm': s += ('0'+(oDate.getMonth()+1)).right(2); break;

			case 'mmm': 

			case 'MMM':

				 tmp = ['Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun', 'Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dic'][oDate.getMonth()];

				 if (RegExp.$1 == 'MMM') tmp = tmp.toUpperCase();

				 s += tmp;

				 break;

			case 'mmmm':  

			case 'MMMM':  

				 tmp = ['Enero', 'Febrero', 'Marzo', 'Abrril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'][oDate.getMonth()]; 

				 if (RegExp.$1 == 'MMMM') tmp = tmp.toUpperCase();

				 s += tmp;

				 break;

			case 'aa':  s += (oDate.getFullYear()+'').right(2); break;

			case 'aaaa':  s += oDate.getFullYear(); break;

			case 'h': s += oDate.getHours(); break;

			case 'hh': s += ('0'+oDate.getHours()).right(2); break;

			case 'n': s += oDate.getMinutes(); break;

			case 'nn': s += ('0'+oDate.getMinutes()).right(2); break;

			case 's': s += oDate.getSeconds(); break;

			case 'ss': s += ('0'+oDate.getSeconds()).right(2); break;			

			default: 

				if (RegExp.$1.length>1 && RegExp.$1.substr(0,1) == '/') s += RegExp.$1.substr(1);

				else s += RegExp.$1;

		}



		pos = RegExp.rightContext.search(re);

	}

	return s;

}



/*-----------------------------------------------------------------------------

  Devuelve true si la cadena contiene una fecha en formato: dd-mm-aaaa o 

  dd/mm/aaaa. El dia y el mes pueden tener un solo dígito.

-----------------------------------------------------------------------------*/

function esFecha(fecha)

{

    var ar;

    var re = /^((\d{1,2})[\/-](\d{1,2})[\/-](\d{4}))$/;

    if (re.test(fecha)) return true;	

    return false;

}



/*-----------------------------------------------------------------------------

  Devuelve true si la cadena contiene una fecha en formato: dd-mm-aaaa o 

  dd/mm/aaaa y además comprueba que sea válida.

  El dia y el mes pueden tener un solo dígito.

-----------------------------------------------------------------------------*/

function esFechaValida(fecha)

{

	var mat, dia, mes, ano;

    var re = /^((\d{1,2})[\/-](\d{1,2})[\/-](\d{4}))$/;

    if (!re.test(fecha)) return false;

    mat = re.exec(fecha);



	dia = mat[2];

	mes = mat[3]++;

	ano = mat[4];



    if (dia==0 || dia > diasMes(mes, ano)) return false;

    if (mes==0 || mes > 12) return false;

    return true;

}



/*-----------------------------------------------------------------------------

  Devuelve los días que tiene un mes de un año en concreto.

-----------------------------------------------------------------------------*/

function diasMes(m, a)

{

    if ((m==4)||(m==6)||(m==9)||(m==11)) return 30;



    if (m==2)

    {

        if (esBisiesto(a)) return 29;

        else return 28;

    }

    return 31;

}



/*-----------------------------------------------------------------------------

  Devuelve true si una año es bisiesto.

-----------------------------------------------------------------------------*/

function esBisiesto(a)

{

    if (((a%4)==0 && (a%100)!=0) || (a%400==0)) return true;

    else return false;

}



//-----------------------------------------------------------------------------

function obtenerDia(fecha)

{

    var ar;

    var re = /^((\d{1,2})[\/-](\d{1,2})[\/-](\d{4}))$/;



    if (!re.test(fecha)) return '';

    ar = re.exec(fecha);

    return ar[2];

}



//-----------------------------------------------------------------------------

function obtenerMes(fecha)

{

    var ar;

    var re = /^((\d{1,2})[\/-](\d{1,2})[\/-](\d{4}))$/;



    if (!re.test(fecha)) return '';

    ar = re.exec(fecha);

    return ar[3];

}



//-----------------------------------------------------------------------------

function obtenerAno(fecha)

{

    var ar;

    var re = /^((\d{1,2})[\/-](\d{1,2})[\/-](\d{4}))$/;



    if (!re.test(fecha)) return '';

    ar = re.exec(fecha);

    return ar[4];

}





/*-----------------------------------------------------------------------------

  Convierte una cadena a una fecha (objeto Date). Si la cadena no tiene una 

  fecha válida un nulo.

-----------------------------------------------------------------------------*/

function strToDate(fecha)

{

    var mat;

    var re = /^((\d{1,2})[\/-](\d{1,2})[\/-](\d{4}))$/;

    if (!re.test(fecha)) return null;

    mat = re.exec(fecha);



    return new Date(mat[4], mat[3]-1, mat[2]);

}