// JavaScript Document

// SOBRE LAS CAPAS
// Las capas padres e hijas hay que definirlas con las siguientes propiedades:
// 		padre:	vis: default	desb:	hidden
// 		hija:	vis: visible	desb:	hidden
// Ademas intentaremos siempre poner los valores de top y left de la capa hija a 0
// para que coincida con la esquina de la capa padre.


//FUNCIONES GLOBALES
//Estas funciones son llamadas desde dentro de las clases para lograr la independencia del navegador
//Su mision es leer o modificar las propiedades de los objetos 

//estas dos primeras funciones sirven para capturar eventos en netscape y usarlos
//de manera similar al exploref
if(!window.event && window.captureEvents) {
  // set up event capturing for mouse events (add or subtract as desired)
  window.captureEvents(Event.MOUSEMOVE|Event.MOUSEOVER|Event.MOUSEOUT|Event.CLICK|Event.DBLCLICK);
  // set window event handlers (add or subtract as desired)
  window.onmousemove = WM_getCursorHandler;
  window.onmouseover = WM_getCursorHandler;
  window.onmouseout = WM_getCursorHandler;
  window.onclick = WM_getCursorHandler;
  window.ondblclick = WM_getCursorHandler;
  // create an object to store the event properties 
  window.event = new Object;
}


function WM_getCursorHandler(e) {
  // set event properties to global vars (add or subtract as desired)
  window.event.clientX = e.pageX;
  window.event.clientY = e.pageY;
  window.event.x = e.layerX;
  window.event.y = e.layerY;
  window.event.screenX = e.screenX;
  window.event.screenY = e.screenY;
  // route the event back to the intended function
  if ( routeEvent(e) == false ) {
    return false;
  } else {
    return true;
  }
}


function comprobarNavegador()
{

	if (navigator.userAgent && navigator.userAgent.indexOf("Mac") >= 0)
        {
		return 3;
	}
	
	if ((navigator.appName).indexOf("Microsoft") == -1)
	{
		if ((navigator.appName).indexOf("Netscape") != -1)
			if (parseInt(navigator.appVersion)>4)
				return 2;
			else 
				return 1;
	}
	else
		return 0;
	
	

}
// 0 -- Internet Explorer 
// 1 -- Netscape 4
// 2 -- Netscape 5
var BROWSER=comprobarNavegador();

function topCapa(id)
{
		
	switch (BROWSER)
	{
		case 0:
			return parseInt(document.all[id].style.top);
		break;
		case 1:
		break;
		case 2:
			
			return parseInt(document.getElementById(id).style.top);
		break;
	}
}

function leftCapa(id)
{
			
	switch (BROWSER)
	{
		case 0:
			return parseInt(document.all[id].style.left);
		break;
		case 1:
		break;
		case 2:
			
			return parseInt(document.getElementById(id).style.left);
		break;
	}
}
function heightCapa(id)
{
			
	switch (BROWSER)
	{
		case 0:
			return parseInt(document.all[id].style.height);
		break;
		case 1:
		break;
		case 2:
			
			return parseInt(document.getElementById(id).style.height);
		break;
	}
}

function widthCapa(id)
{
		
	switch (BROWSER)
	{
		case 0:
			return parseInt(document.all[id].style.width);
		break;
		case 1:
		break;
		case 2:
			
			return parseInt(document.getElementById(id).style.width);
		break;
	}
}

function offsetHeightCapa(id)
{
	
		
		switch (BROWSER)
	{
		case 0:
			return parseInt(document.all[id].offsetHeight);
		break;
		case 1:
		break;
		case 2:
			
			return parseInt(document.getElementById(id).style.height);
		break;
	}
}

function offsetWidthCapa(id)
{
		
		switch (BROWSER)
	{
		case 0:
			return parseInt(document.all[id].offsetWidth);
		break;
		case 1:
		break;
		case 2:
			
			return parseInt(document.getElementById(id).style.width);
		break;
	}
}

function cambiarTopCapa(id,valor)
{
			
	switch (BROWSER)
	{
		case 0:
			document.all[id].style.top=valor;
		break;
		case 1:
		break;
		case 2:
			
			document.getElementById(id).style.top=valor
		break;
	}
	
	
}

function cambiarLeftCapa(id,valor)
{
	switch (BROWSER)
	{
		case 0:
			document.all[id].style.left=valor;
		break;
		case 1:
		break;
		case 2:
			
			document.getElementById(id).style.left=valor
		break;
	}
	
}

function celdasFilaTabla(id)
{
	switch (BROWSER)
	{
		case 0:
			return document.all[id].cells;
		break;
		case 1:
		break;
		case 2:
			
			return document.getElementById(id).cells;
		break;
	}
}

function filasTabla(id)
{
	switch (BROWSER)
	{
		case 0:
			return document.all[id].rows;
		break;
		case 1:
		break;
		case 2:			
			return document.getElementById(id).rows;
		break;
	}
}	
	

function visibleCapa(id)
{
	switch (BROWSER)
	{
		case 0:
			document.all[id].style.visibility="visible";
		break;
		case 1:
		break;
		case 2:			
			document.getElementById(id).style.visibility="visible";
		break;
	}
	
}

function hiddenCapa(id)
{
	switch (BROWSER)
	{
		case 0:
			document.all[id].style.visibility="hidden";
		break;
		case 1:
		break;
		case 2:			
			document.getElementById(id).style.visibility="hidden";
		break;
	}
}

function widthImagen(id)
{
	switch (BROWSER)
	{
		case 0:
			return parseInt(document.all[id].width);
		break;
		case 1:
		break;
		case 2:			
			return parseInt(document.getElementById(id).width);
		break;
	}
	
}

function heightImagen(id)
{
	switch (BROWSER)
	{
		case 0:
			return parseInt(document.all[id].height);
		break;
		case 1:
		break;
		case 2:			
			return parseInt(document.getElementById(id).height);
		break;
	}
	
}

function cambiarHeightImagen(id,valor)
{
	switch (BROWSER)
	{
		case 0:
			document.all[id].height=valor;
		break;
		case 1:
		break;
		case 2:			
			document.getElementById(id).height=valor;
		break;
	}

	
}

function cambiarWidthImagen(id,valor)
{
	switch (BROWSER)
	{
		case 0:
			document.all[id].width=valor;
		break;
		case 1:
		break;
		case 2:			
			document.getElementById(id).width=valor;
		break;
	}
}
function absolutaX()
{
	switch (BROWSER)
	{
		case 0:
			return document.body.scrollLeft + window.event.x;
		break;
		case 1:
		break;
		case 2:			
			return window.event.clientX;
		break;
	}
}

function absolutaY()
{
	switch (BROWSER)
	{
		case 0:
			return document.body.scrollTop + window.event.y;
		break;
		case 1:
		break;
		case 2:			
			return window.event.clientY;
		break;
	}
}
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase ScrollZoom
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Se trata de un scroll sobre una imagen y con unos botones podremos desplazarla y hacer zoom
//
// METODOS:
//
// ---------- ScrollZoom(padre,hija,idimagen,anchoimagen,altoimagen)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padre:	una cadena con el identificador de la capa padre.
//		hija: una cadena con el identificador de la capa hija donde estara la foto original
//		padre: 	una cadena con la capa padre que actuara como visor de la imagen aumentada
//		idimagen:	cadena con el identificador de la imagen original
//		anchoimagen: ancho de la imagen original
//		altoimagen:	alto de la imagen original
//
// ---------- mover(movtop,movleft,intervalo)
// Llamando a este metodo moveremos la imagen por la ventana. parametros:
//		movtop:	numero de pixeles verticales que moveremos cada vez (<0 para arriba)
//		movleft:	numero de pixeles horizontales que moveremos cada vez (<0 para la izquierda) 
//		intervalo: cada cuantos milisegundos se realizara el moivimiento
//
// ---------- zoom(valor,intervalo)
// LLamando a esta funcion aumentaremos el porcentaje indicado en valor el tamaño de la foto cada 
// periodo indicado en intervalo. Valores negativos aumentan
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var z = new ScrollZoom("Layer1","Layer2","idmapa",1000,500)
// Despues definiremos varios botones que al pasar sobre ellos realizen las llamadas a las funciones
// ademas a cada boton abra que llamar en el evento onMouseOut a:
//		z.parar()
// Ejemplos de botones:
//	arriba		z.mover(-10,0,100);
// 	abajo		z.mover(10,0,100);
//	izquierda	z.mover(0,-10,100);
//	derecha		z.mover(0,10,100);
//  aumentar	z.zoom(3,100);
//	disminuir	z.zoom(-1,100);

function ScrollZoom(padre,hija,idimagen,anchoimagen,altoimagen)
{
	this.padre=padre;
	this.hija=hija;
	this.idimagen=idimagen;
	this.ANCHOIMAGEN=anchoimagen;
	this.ALTOIMAGEN=altoimagen;
	this.TIMERID1=0;
}

ScrollZoom.prototype.movimiento = function(movtop,movleft)
{
	var left=leftCapa(this.hija);
	var top=topCapa(this.hija)
	var anchoFoto=widthImagen(this.idimagen);
	var altoFoto=heightImagen(this.idimagen);
	var altoCapa=heightCapa(this.padre);
	var anchoCapa=widthCapa(this.padre);
	
	var nuevoTop=top + movtop;
	var nuevoLeft=left + movleft;
	
	if (nuevoTop>0) nuevoTop=0;
	if (nuevoTop<altoCapa-altoFoto) nuevoTop=altoCapa-altoFoto;
	if (nuevoLeft>0) nuevoLeft=0;
	if (nuevoLeft<anchoCapa-anchoFoto) nuevoLeft=anchoCapa-anchoFoto;

	cambiarTopCapa(this.hija,nuevoTop);
	cambiarLeftCapa(this.hija,nuevoLeft);
}

ScrollZoom.prototype.mover = function(movtop,movleft,intervalo)
{
	var thisobj=this;
	var funcion = function () {thisobj.movimiento(movtop,movleft)};
	this.TIMERID1 = setInterval(funcion,intervalo);
}

ScrollZoom.prototype.parar = function()
{
	clearInterval(this.TIMERID1);
}

ScrollZoom.prototype.hacerZoom = function(valor)
{

	var left=leftCapa(this.hija);
	var top=topCapa(this.hija);
	var anchoFoto=widthImagen(this.idimagen);
	var altoFoto=heightImagen(this.idimagen);
	var altoCapa=heightCapa(this.padre);
	var anchoCapa=widthCapa(this.padre);
	var mitadCapaX=Math.round(anchoCapa/2);
	var mitadCapaY=Math.round(altoCapa/2);
	
	var porcentajeX=Math.abs(Math.round(((-left+mitadCapaX)/anchoFoto)*100));
	var porcentajeY=Math.abs(Math.round(((-top+mitadCapaY)/altoFoto)*100));
		
	var restaX=Math.round((valor*anchoFoto)/100);
	var restaY=Math.round((valor*altoFoto)/100);
	
	var nuevoAncho=anchoFoto-restaX;
	var nuevoAlto=altoFoto-restaY;

	if (nuevoAncho>this.ANCHOIMAGEN) 
	{
		nuevoAncho=this.ANCHOIMAGEN;
		nuevoAlto=this.ALTOIMAGEN;
	}
	if (nuevoAncho<anchoCapa) return;
	if (nuevoAlto>this.ALTOIMAGEN) 
	{
		nuevoAncho=this.ANCHOIMAGEN;
		nuevoAlto=this.ALTOIMAGEN;

	}
	if (nuevoAlto<altoCapa) return;
	
	cambiarWidthImagen(this.idimagen,nuevoAncho);
	cambiarHeightImagen(this.idimagen,nuevoAlto);
		
	var despX=Math.round((nuevoAncho*porcentajeX)/100);
	var despY=Math.round((nuevoAlto*porcentajeY)/100);
	
	var nuevoTop=mitadCapaY-despY;
	var nuevoLeft=mitadCapaX-despX;
		
	if (nuevoTop>0) nuevoTop=0;
	if (nuevoTop<altoCapa-nuevoAlto) nuevoTop=altoCapa-nuevoAlto;
	if (nuevoLeft>0) nuevoLeft=0;
	if (nuevoLeft<anchoCapa-nuevoAncho) nuevoLeft=anchoCapa-nuevoAncho;
	
	cambiarLeftCapa(this.hija,nuevoLeft);
	cambiarTopCapa(this.hija,nuevoTop);
}

ScrollZoom.prototype.zoom = function(valor,intervalo)
{
	//alert("hola");
	var thisobj=this;
	var funcion = function () {thisobj.hacerZoom(valor)};
	this.TIMERID1 = setInterval(funcion,intervalo);
}

//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase ScrollAumentar
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Se trata de un scroll que hace que apuntes a una foto pequeña con una lupa y se te muestre en otra
// ventana la zona marcada ampliada.
//
// METODOS:
//
// ---------- ScrollAumentar(padreminiatura,capalupa,padre,hija,fotogrande,margenborde,fotogramas)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padreminiatura:	una cadena con el identificador de la capa que albergara la fotografia pequeña.
//		capalupa: una cadena con el nombre de la capa que contendra la imagen para marcar la zona
//		padre: 	una cadena con la capa padre que actuara como visor de la imagen aumentada
//		hija: una cadena con la capa hija que albergara la foto ampliada
//		fotogrande: una cadena con el identificador de la foto aumentada
//		margenborde: una cantidad par corregir el error al llegar a los bordes
//		fotogramas: el numero de fotogramas que quieres para suavizar el movimiento
//
// ---------- cambiar()
// Llamando a este metodo se mostrara la parte de la foto aumentada correspondiente a la posicion de la foto 
// pequeña donde estamos
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var aumentar= new ScrollAumentar("Layer31","Layer32","Layer33","Layer34","foto2",5,5)
// Despues definiremos en el evento OnMouseMove de la capa padre de la foto pequeña y de la capa de la lupa
// una llamada a cambiar
//		aumentar.cambiar()
// Asignaremos a los eventos OnMouseOver y OnMouseOut las llamada que muestran y ocultan la lupa respectivamente
// 		aumentar.mostrarLupa()		aumentar.ocultarLupa()
// Para definir un control que no use lupa, no definiremos la capa de la lupa y llamaremos al constructor con la cadena vacia
//		var aumentarSinLupa= new ScrollAumentar("Layer31","","Layer33","Layer34","foto2",5,5)
// Tambien evitaremos las llamadas a mostrarLupa() y ocultarLupa()		

function ScrollAumentar(padreminiatura,capalupa,padre,hija,fotogrande,margenborde,fotogramas)
{
	this.padreminiatura=padreminiatura;
	this.capalupa=capalupa;
	this.padre=padre;
	this.hija=hija;
	this.fotogrande=fotogrande;
	this.margenborde=margenborde;
	this.fotogramas=fotogramas;
	this.VIEJOTOP=0;
	this.VIEJOLEFT=0;
}

ScrollAumentar.prototype.mostrarLupa = function()
{
	visibleCapa(this.capalupa);
}

ScrollAumentar.prototype.ocultarLupa = function()
{
	hiddenCapa(this.capalupa);
}

ScrollAumentar.prototype.cambiar = function()
{
	var posX=absolutaX();
	var posY=absolutaY();
	
			
	var orX=leftCapa(this.padreminiatura);
	var orY=topCapa(this.padreminiatura);
	
	var alto=heightCapa(this.padreminiatura);
	var ancho=widthCapa(this.padreminiatura);

	var finX=posX-orX;
	var finY=posY-orY;
	
	if (this.capalupa != "")
	{
		anchoLupa=widthCapa(this.capalupa);
		altoLupa=heightCapa(this.capalupa);
	
		lupatop=finY - Math.round(altoLupa / 2);
		lupaleft=finX - Math.round(anchoLupa /2);
		
		if (lupatop<0) lupatop=0;
		if (lupatop>alto-altoLupa) lupatop=alto-altoLupa;
		if (lupaleft<0) lupaleft=0;
		if (lupaleft>ancho-anchoLupa) lupaleft=ancho-anchoLupa;	
	
		cambiarTopCapa(this.capalupa,lupatop);
		cambiarLeftCapa(this.capalupa,lupaleft);
	}
	
	var porcentajeX=Math.round((finX/ancho)*100);
	var porcentajeY=Math.round((finY/alto)*100);

	var anchoFoto=widthImagen(this.fotogrande);
	var altoFoto=heightImagen(this.fotogrande);
	
	var anchoLayer=widthCapa(this.padre);
	var altoLayer=heightCapa(this.padre);

	var nuevotop=-Math.round((altoFoto*porcentajeY)/100) + altoLayer/2;
	var nuevoleft=-Math.round((anchoFoto*porcentajeX)/100) + anchoLayer/2;
	
	if (nuevotop>-this.margenborde) nuevotop=0;
	if (nuevoleft>-this.margenborde) nuevoleft=0;
	if (nuevotop <= altoLayer-altoFoto+this.margenborde) nuevotop=altoLayer-altoFoto;
	if (nuevoleft <= anchoLayer-anchoFoto+this.margenborde) nuevoleft=anchoLayer-anchoFoto;
	
	var dy=nuevotop-this.VIEJOTOP;
	var saltoy=Math.round(dy/this.fotogramas);
	
	var dx=nuevoleft-this.VIEJOLEFT;
	var saltox=Math.round(dy/this.fotogramas);
	
	
	
	if (nuevotop<=0 && nuevotop>= altoLayer-altoFoto)
	{
		for (i=1;i<this.fotogramas;i++)
			cambiarTopCapa(this.hija,this.VIEJOTOP + i*saltoy);
		
		cambiarTopCapa(this.hija,nuevotop);
	}
	if (nuevoleft<=0 && nuevoleft>= anchoLayer-anchoFoto)
	{
		for (i=1;i<5;i++)
			cambiarLeftCapa(this.hija,this.VIEJOLEFT + i*saltox);
		cambiarLeftCapa(this.hija,nuevoleft);
	}
	this.VIEJOTOP=nuevotop;
	this.VIEJOLEFT=nuevoleft;
}


//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase ScrollParadaVer
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Se trata de un scroll que muestra noticias de forma vertical en un bucle a una cierta velocidad y que se queda
// parado cuando un tiempo predeterminado en cada noticia
//
// METODOS:
//
// ---------- ScrollParadaVer(padre,hija,idtabla,valor,intervalo,espera)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padre:	una cadena con el identificador de la capa padre.
//		hija:	una cadena con el identificador de la capa hija.
//		idtabla:	una cadena con el identificador de las tablas donde se encuentran todas las celdas con las noticias
//		valor:	numero de pixeles que se correran cada vez (<0 se desplaza hacia arriba)
//		intervalo:	cada cuantos milisegundos se produce el desplazamiento
//		espera: cuantos milisegundos se espera entre noticia y noticia
//
// ---------- bucle()
// Este metodo hace que comience el bucle
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var v = new ScrollParadaVer("Layer1","Layer2¨","tabla2",10,50,3000) ;
// Despues de tener definidas las capas realizamos una llamada a bucle para que comience a funcionar
//		p.bucle();
// Parara 3 segundos entre noticia y noticia
//
// CONSEJOS:
// 
// Para evitar que las noticias no queden centradas poner el alto de las celdas proporcional a los pixeles que
// queremos desplazar cada vez, y todas del mismo tamaño

function ScrollParadaVer(padre,hija,idtabla,valor,intervalo,espera)
{
	this.padre=padre;
	this.hija=hija;
	this.idtabla=idtabla;
	this.valor=valor;
	this.intervalo=intervalo;
	this.espera=espera;
	this.ALTOACTUAL=0;
	this.NOTICIA=0;
	this.TIMERID1=0;
}

ScrollParadaVer.prototype.desplazamiento = function()
{

	var top;

	top=topCapa(this.hija);

	var filas=filasTabla(this.idtabla);
	var celdas=filas[0].cells; //todas las celdas deben ser del mismo tamanio
	var altoceldas=parseInt(celdas[0].height);

	if (this.valor>0)
		if (top < -(this.ALTOACTUAL-altoceldas))	
			cambiarTopCapa(this.hija,top + this.valor) ;
		else
		{	
			clearInterval(this.TIMERID1);
			
			this.NOTICIA = this.NOTICIA - 1;
			if (this.NOTICIA < 0)
			{
				this.NOTICIA=filas.length-1;
				this.ALTOACTUAL=(filas.length*altoceldas - altoceldas);
				cambiarTopCapa(this.hija,-this.ALTOACTUAL);
			
			}
			else
				this.ALTOACTUAL = this.ALTOACTUAL - altoceldas;
			
			var thisobj=this;
			var funcion = function () {thisobj.bucle()};
			setTimeout(funcion,this.espera);
		}	
	
	if (this.valor<0)
		
			if (top> - (this.ALTOACTUAL + altoceldas)) // si pones >= de descoloca
				cambiarTopCapa(this.hija,top + this.valor);
			else
			{	
				clearInterval(this.TIMERID1);
				
				this.NOTICIA = this.NOTICIA + 1;
				if (this.NOTICIA == filas.length)
				{
					this.NOTICIA=0;
					this.ALTOACTUAL=0;
					cambiarTopCapa(this.hija,0);
				}
				else
					this.ALTOACTUAL = this.ALTOACTUAL + altoceldas;
				
				var thisobj=this;
				var funcion = function () {thisobj.bucle()};
				setTimeout(funcion,this.espera);
			}
}

ScrollParadaVer.prototype.bucle = function()
{
	if (  this.valor==0 || this.intervalo==0) return;
	
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento()};
	this.TIMERID1 = setInterval(funcion,this.intervalo);
}


//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase ScrollParadaHor
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Se trata de un scroll que muestra noticias de forma horizontal en un bucle a una cierta velocidad y que se queda
// parado cuando un tiempo predeterminado en cada noticia
//
// METODOS:
//
// ---------- ScrollParadaHor(padre,hija,idtr,valor,intervalo,espera)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padre:	una cadena con el identificador de la capa padre.
//		hija:	una cadena con el identificador de la capa hija.
//		idtr:	una cadena con el identificador del <tr> donde se encuentran todas las celdas con las noticias
//		valor:	numero de pixeles que se correran cada vez (<0 se desplaza hacia la izquierda)
//		intervalo:	cada cuantos milisegundos se produce el desplazamiento
//		espera: cuantos milisegundos se espera entre noticia y noticia
//
// ---------- bucle()
// Este metodo hace que comience el bucle
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var p = new ScrollParadaHor("Layer1","Layer2¨","mitr",-10,50,3000) ;
// Despues de tener definidas las capas realizamos una llamada a bucle para que comience a funcionar
//		p.bucle();
// Parara 3 segundos entre noticia y noticia
//
// CONSEJOS:
// 
// Para evitar que las noticias no queden centradas poner el ancho de las celdas proporcional a los pixeles que
// queremos desplazar cada vez, y todas del mismo tamaño

function ScrollParadaHor(padre,hija,idtr,valor,intervalo,espera)
{
	this.padre=padre;
	this.hija=hija;
	this.idtr=idtr;
	this.valor=valor;
	this.intervalo=intervalo;
	this.espera=espera;
	this.ANCHOACTUAL=0;
	this.NOTICIA=0;
	this.TIMERID1=0;
}

ScrollParadaHor.prototype.desplazamiento = function()
{
	var izquierda;

	izquierda=leftCapa(this.hija);

	var celdas = celdasFilaTabla(this.idtr);
	
	//todas las celdas deben ser del mismo tamanio
	var anchocelda=parseInt(celdas[0].width);
	
	if (this.valor>0)
		if (izquierda < -(this.ANCHOACTUAL-anchocelda))	
			cambiarLeftCapa(this.hija,izquierda + this.valor) ;
		else
		{	
			clearInterval(this.TIMERID1);
			
			this.NOTICIA = this.NOTICIA - 1;
			if (this.NOTICIA < 0)
			{
				this.NOTICIA=celdas.length-1;
				this.ANCHOACTUAL=(celdas.length*anchocelda - anchocelda);
				cambiarLeftCapa(this.hija,-this.ANCHOACTUAL);
			
			}
			else
				this.ANCHOACTUAL = this.ANCHOACTUAL - anchocelda;
			
			var thisobj=this;
			var funcion = function () {thisobj.bucle()};
			setTimeout(funcion,this.espera);
		}	
	
	if (this.valor<0)
		
			if (izquierda> - (this.ANCHOACTUAL + anchocelda)) // si pones >= de descoloca
				cambiarLeftCapa(this.hija,izquierda + this.valor);
			else
			{	
				clearInterval(this.TIMERID1);
				
				this.NOTICIA = this.NOTICIA + 1;
				if (this.NOTICIA == celdas.length)
				{
					this.NOTICIA=0;
					this.ANCHOACTUAL=0;
					cambiarLeftCapa(this.hija,0);
				}
				else
					this.ANCHOACTUAL = this.ANCHOACTUAL + anchocelda;
				
				var thisobj=this;
				var funcion = function () {thisobj.bucle()};
				setTimeout(funcion,this.espera);
			}
}

ScrollParadaHor.prototype.bucle = function()
{
	if (  this.valor==0 || this.intervalo==0) return;
	
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento()};
	this.TIMERID1 = setInterval(funcion,this.intervalo);
}

//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase ScrollNoticiaHor
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Se trata de un scroll que mediante eventos nos permite pasar de unas noticias a otras que estan dentro de una tabla
// Se puede controlar la velocidad de pasar de una noticia a otra. Para ello usamos una tabla con una fila y cada
// columna con el mismo tamaño que la capa padre.
//
// METODOS:
//
// ---------- ScrollNoticiaHor(padre,hija,idtr)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padre:	una cadena con el identificador de la capa padre.
//		hija:	una cadena con el identificador de la capa hija.
//		idtr:	una cadena con el identificador del <tr> donde se encuentran todas las celdas con las noticias
//
// ---------- desplazar(valor,intervalo)
// Este método desplaza las noticias a la izquierda(valor<0) o a la derecha (valor>0). Parametros:
// 		valor:	cuantos pixeles queremos desplazar de cada vez. (<0 hacia arriba)
//		intervalo:	cada cuantos milisegundos se realiza el desplazamiento
// Cuando llega a la siguiente noticia o a la anterior para
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var shNoticia = new ScrollNoticiaHor("Layer1","Layer2","idtrtabla"); 
// Lo normal es tener unos boton que al pulsar realize el desplazamiento 
//		izquierda:		shNoticia.desplazar(-10,200);
// 		derecha:		shNoticia.desplazar(10,200);
// CONSEJOS:
// 
// Para evitar que las noticias no queden centradas poner el ancho de las celdas proporcional a los pixeles que
// queremos desplazar cada vez, y todas del mismo tamaño



function ScrollNoticiaHor(padre,hija,idtr)
{
	this.padre=padre;
	this.hija=hija;
	this.idtr=idtr;
	this.TIMERID1=0;
	this.NOTICIA=0;
	this.ANCHOACTUAL=0;
}

ScrollNoticiaHor.prototype.desplazamientoHorPar = function(valor)
{

	var izquierda;
	
	izquierda=leftCapa(this.hija);
			
	//devuelve una coleccion de celdas
	var celdas = celdasFilaTabla(this.idtr);

	//todas las celdas deben ser del mismo tamanio
	var anchocelda=parseInt(celdas[0].width);
	
	if (valor>0)
		if (izquierda < -(this.ANCHOACTUAL-anchocelda))	
			cambiarLeftCapa(this.hija,izquierda + valor) ;
		else
		{	
			clearInterval(this.TIMERID1);
			this.NOTICIA = this.NOTICIA - 1;
			if (this.NOTICIA < 0)
			{
				this.NOTICIA=celdas.length-1;
				this.ANCHOACTUAL=(celdas.length*anchocelda - anchocelda);
				cambiarLeftCapa(this.hija,-this.ANCHOACTUAL);
			
			}
			else
				this.ANCHOACTUAL = this.ANCHOACTUAL - anchocelda;
			this.TIMERID1=0;
		}	
	
	if (valor<0)
		//if (izquierda>=anchopadre-anchohijo)
			if (izquierda> - (this.ANCHOACTUAL + anchocelda)) // si pones >= de descoloca
				cambiarLeftCapa(this.hija,izquierda + valor);
			else
			{	
				clearInterval(this.TIMERID1);
				this.NOTICIA = this.NOTICIA + 1;
				if (this.NOTICIA == celdas.length)
				{
					this.NOTICIA=0;
					this.ANCHOACTUAL=0;
					cambiarLeftCapa(this.hija,0);
				}
				else
					this.ANCHOACTUAL = this.ANCHOACTUAL + anchocelda;
				this.TIMERID1=0;
				
		}
}

ScrollNoticiaHor.prototype.desplazar = function(valor,intervalo)
{
	if (  valor==0 || intervalo==0 || this.TIMERID1!=0) return;
	
	var thisobj=this;
	var funcion = function () {thisobj.desplazamientoHorPar(valor)};
	this.TIMERID1 = setInterval(funcion,intervalo);
}


//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase ScrollNoticiaVer
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Se trata de un scroll que mediante eventos nos permite pasar de unas noticias a otras que estan dentro de una tabla
// Se puede controlar la velocidad de pasar de una noticia a otra. Para ello usamos una tabla con una fila para cada tamaño
// y todas del mismo tamaño e igual a la altura de la ventana padre
//
// METODOS:
//
// ---------- ScrollNoticiaVer(padre,hija,idtabla)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padre:	una cadena con el identificador de la capa padre.
//		hija:	una cadena con el identificador de la capa hija.
//		idtabla:	una cadena con el identificador de la tabla donde se encuentran las noticias
//
// ---------- desplazar(valor,intervalo)
// Este método desplaza las noticias hacia arriba(valor<0) o hacia abajo (valor>0). Parametros:
// 		valor:	cuantos pixeles queremos desplazar de cada vez. (<0 hacia arriba)
//		intervalo:	cada cuantos milisegundos se realiza el desplazamiento
// Cuando llega a la siguiente noticia o a la anterior para
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var svNoticia = new ScrollNoticiaBer("Layer1","Layer2","mitabla"); 
// Lo normal es tener unos boton que al pulsar realize el desplazamiento 
//		arriba:		shNoticia.desplazar(-10,200);
// 		abajo:		shNoticia.desplazar(10,200);
// CONSEJOS:
// 
// Para evitar que las noticias no queden centradas poner el alto de las celdas proporcional a los pixeles que
// queremos desplazar cada vez, y todas del mismo tamaño

function ScrollNoticiaVer(padre,hija,idtabla)
{
	this.padre=padre;
	this.hija=hija;
	this.idtabla=idtabla;
	this.TIMERID1=0;
	this.NOTICIA=0;
	this.ALTOACTUAL=0;
}

ScrollNoticiaVer.prototype.desplazamientoVerPar = function (valor)
{
	var top;
	
	top=topCapa(this.hija);
		
	var filas=filasTabla(this.idtabla);
	var celdas=filas[0].cells; //todas las celdas deben ser del mismo tamanio
	var altoceldas=parseInt(celdas[0].height);
		
	if (valor>0)
		if (top < -(this.ALTOACTUAL-altoceldas))	
			cambiarTopCapa(this.hija,top + valor) ;
		else
		{	
			clearInterval(this.TIMERID1);
			this.NOTICIA = this.NOTICIA - 1;
			if (this.NOTICIA < 0)
			{
				this.NOTICIA=filas.length-1;
				this.ALTOACTUAL=(filas.length*altoceldas - altoceldas);
				cambiarTopCapa(this.hija,-this.ALTOACTUAL);
			
			}
			else
				this.ALTOACTUAL = this.ALTOACTUAL - altoceldas;
			this.TIMERID1=0;
		}	
	
	if (valor<0)
		
			if (top > - (this.ALTOACTUAL + altoceldas)) // si pones >= de descoloca
				cambiarTopCapa(this.hija,top + valor);
			else
			{	
				clearInterval(this.TIMERID1);
				this.NOTICIA = this.NOTICIA + 1;
				if (this.NOTICIA == filas.length)
				{
					this.NOTICIA=0;
					this.ALTOACTUAL=0;
					cambiarTopCapa(this.hija,0);
				}
				else
					this.ALTOACTUAL = this.ALTOACTUAL + altoceldas;
				
				
				this.TIMERID1=0;
			}
}

ScrollNoticiaVer.prototype.desplazar = function (valor,intervalo)
{
	if (  valor==0 || intervalo==0 || this.TIMERID1!=0) return;
		
	var thisobj=this;
	var funcion = function () {thisobj.desplazamientoVerPar(valor)};
	this.TIMERID1 = setInterval(funcion,intervalo);
}

//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase ScrollHor
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Implementa un scroll Vertical. Se podra subir y bajar el texto y cambiar la velocidad pasado un tiempo.
// tambien se podra poner otra velocidad al acercarnos al final.
//
// METODOS:
//
// ---------- ScrollVer(padre,hija)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padre:	una cadena con el identificador de la capa padre.
//		hija:	una cadena con el identificador de la capa hija.
//
// ---------- desplazar(valor,intervalo,espera,nuevoValor,nuevoIntervalo,porcentaje,v,i)
// Este método comienza a hacer el scroll. Parametros:
// 		valor:	cuantos pixeles queremos desplazar de cada vez. (<0 hacia arriba)
//		intervalo:	cada cuantos milisegundos se realiza el desplazamiento
//		espera:		cuanto tiempo(ms) hay que esperar para cambiar la velocidad al valor de los siguientes parametros
//		nuevoValor:	nueva cantidad de pizeles a desplazar al pasar el tiempo de espera
//		nuevoIntervalo:	nuevo intervalo de tiempo(ms) despues de llegar al tiempo de espera
//		porcentaje:	el porcentaje de la altura total de la capa hija que faltara para realizar el cambio de velocidad con los siguientes parametros
//		v:	nuevo valor cuando alcancemos el porcentaje final.
//		i: nuevo intervalo cuando alcancemos el porcentaje final.
//
// ---------- cambiarDesplazamiento(valor,intervalo,porcentaje,v,i)
// Este metodo cambia el desplazamiento del bucle. Parametros:
// 		valor:	cuantos pixeles queremos desplazar de cada vez. (<0 hacia arriba)
//		intervalo:	cada cuantos milisegundos se realiza el desplazamiento
//		porcentaje:	el porcentaje de la altura total de la capa hija que faltara para realizar el cambio de velocidad con los siguientes parametros
//		v:	nuevo valor cuando alcancemos el porcentaje final.
//		i: nuevo intervalo cuando alcancemos el porcentaje final.	
//
// ---------- parar()
// Para el scroll.
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var sv = new ScrollVer("Layer1","Layer2"); 
// Lo normal es tener unos botones que cuando nos posemos sobre ellos realizemos una llamada así:
//		sv.desplazar(-10,200,3000,-10,50,15,-10,300);
// Comienza a desplazarse hacia arriba a velocidad (-10,200), cuando pasan 3 segundos pasa a velocidad (-10,50) mas rapida
// y por ultimo cuando falta el 15% de la altura total cambia a velocidad mas lenta (-10,300)
// Tambien se puede asociar al evento OnClick un cambio de velocidad
// 		sv.cambiarDesplazamiento(-10,50,15,-10,300)

function ScrollHor(padre,hija)
{
	this.padre=padre;
	this.hija=hija;
	this.TIMERID1=0;
	this.TIMERID2=0;
}

ScrollHor.prototype.desplazamiento = function(valor,porcentaje,v,i)
{
	var anchohijo;
	var anchopadre;
	var izquierda;
	
	anchohijo=offsetWidthCapa(this.hija);
	anchopadre=widthCapa(this.padre);
	izquierda=leftCapa(this.hija);

	//comprobamos si estamos llegando al final
	var porcion=Math.round(anchohijo*porcentaje/100);
    
	if (izquierda+anchohijo-anchopadre<=porcion && valor<0)
	{	
		this.llegaPorcentaje(v,i);
		return;
	}
	

	if ( izquierda>= -porcion && valor>0)
	{
	
		this.llegaPorcentaje(v,i);
		return;
	
	}

	if (izquierda<0 && valor>0)
		cambiarLeftCapa(this.hija,izquierda + valor);
	
	if (valor<0 && izquierda>=anchopadre-anchohijo)
		cambiarLeftCapa(this.hija,izquierda + valor);	
}

ScrollHor.prototype.desplazamientoNuevo = function(valor,intervalo,porcentaje,v,i)
{
	if (  valor==0 || intervalo==0 || porcentaje==0 || v==0 || i==0) return;
	
	clearInterval(this.TIMERID1);
	
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento(valor,porcentaje,v,i)};
	this.TIMERID1 = setInterval(funcion,intervalo);
}

ScrollHor.prototype.desplazar = function(valor,intervalo,espera,nuevoValor,nuevoIntervalo,porcentaje,v,i)
{
	if (  valor==0 || intervalo==0 || nuevoValor==0 || nuevoIntervalo==0 || porcentaje==0 || v==0 || i==0) return;
		
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento(valor,porcentaje,v,i)};
	var funcion2 = function () {thisobj.desplazamientoNuevo(nuevoValor,nuevoIntervalo,porcentaje,v,i)};
	this.TIMERID1 = setInterval(funcion,intervalo);
	this.TIMERID2 = setTimeout(funcion2,espera);
}

ScrollHor.prototype.llegaPorcentaje = function(v,i)
{
	clearInterval(this.TIMERID1);
	clearTimeout(this.TIMERID2);

	var thisobj=this;
	var funcion = function () {thisobj.desplazamientoFinal(v)};
	this.TIMERID1 = setInterval(funcion,i);
}

ScrollHor.prototype.desplazamientoFinal = function(v)
{
	var anchohijo;
	var anchopadre;
	var izquierda;
	
	anchohijo=offsetWidthCapa(this.hija);
	anchopadre=widthCapa(this.padre);
	izquierda=leftCapa(this.hija);

	if (izquierda<0 && v>0)
	{
		cambiarLeftCapa(this.hija,izquierda + v);
		return;
	}
	if (v<0 && izquierda>=anchopadre-anchohijo)
	{
		cambiarLeftCapa(this.hija,izquierda + v);
		return;
	}
	
	//si llegamos aqui es que alcanzamos el final
	clearInterval(this.TIMERID1);
}

ScrollHor.prototype.cambiarDesplazamiento = function(valor,intervalo,porcentaje,v,i)
{
	if (  valor==0 || intervalo==0 || porcentaje==0 || v==0 || i==0) return;
	
	clearInterval(this.TIMERID1);
	clearTimeout(this.TIMERID2);
	
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento(valor,porcentaje,v,i)};
	this.TIMERID1 = setInterval(funcion,intervalo);

}



ScrollHor.prototype.parar = function()
{
	clearInterval(this.TIMERID1);
	clearTimeout(this.TIMERID2);
}



//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase ScrollVer
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Implementa un scroll Vertical. Se podra subir y bajar el texto y cambiar la velocidad pasado un tiempo.
// tambien se podra poner otra velocidad al acercarnos al final.
//
// METODOS:
//
// ---------- ScrollVer(padre,hija)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padre:	una cadena con el identificador de la capa padre.
//		hija:	una cadena con el identificador de la capa hija.
//
// ---------- desplazar(valor,intervalo,espera,nuevoValor,nuevoIntervalo,porcentaje,v,i)
// Este método comienza a hacer el scroll. Parametros:
// 		valor:	cuantos pixeles queremos desplazar de cada vez. (<0 hacia arriba)
//		intervalo:	cada cuantos milisegundos se realiza el desplazamiento
//		espera:		cuanto tiempo(ms) hay que esperar para cambiar la velocidad al valor de los siguientes parametros
//		nuevoValor:	nueva cantidad de pizeles a desplazar al pasar el tiempo de espera
//		nuevoIntervalo:	nuevo intervalo de tiempo(ms) despues de llegar al tiempo de espera
//		porcentaje:	el porcentaje de la altura total de la capa hija que faltara para realizar el cambio de velocidad con los siguientes parametros
//		v:	nuevo valor cuando alcancemos el porcentaje final.
//		i: nuevo intervalo cuando alcancemos el porcentaje final.
//
// ---------- cambiarDesplazamiento(valor,intervalo,porcentaje,v,i)
// Este metodo cambia el desplazamiento del bucle. Parametros:
// 		valor:	cuantos pixeles queremos desplazar de cada vez. (<0 hacia arriba)
//		intervalo:	cada cuantos milisegundos se realiza el desplazamiento
//		porcentaje:	el porcentaje de la altura total de la capa hija que faltara para realizar el cambio de velocidad con los siguientes parametros
//		v:	nuevo valor cuando alcancemos el porcentaje final.
//		i: nuevo intervalo cuando alcancemos el porcentaje final.	
//
// ---------- parar()
// Para el scroll.
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var sv = new ScrollVer("Layer1","Layer2"); 
// Lo normal es tener unos botones que cuando nos posemos sobre ellos realizemos una llamada así:
//		sv.desplazar(-10,200,3000,-10,50,15,-10,300);
// Comienza a desplazarse hacia arriba a velocidad (-10,200), cuando pasan 3 segundos pasa a velocidad (-10,50) mas rapida
// y por ultimo cuando falta el 15% de la altura total cambia a velocidad mas lenta (-10,300)
// Tambien se puede asociar al evento OnClick un cambio de velocidad
// 		sv.cambiarDesplazamiento(-10,50,15,-10,300)

function ScrollVer(padre,hija)
{
	this.padre=padre;
	this.hija=hija;
	this.TIMERID1=0;
	this.TIMERID2=0;
}

ScrollVer.prototype.desplazamiento = function(valor,porcentaje,v,i)
{
	var alturahijo;
	var alturapadre;
	var top;
	
	alturahijo=offsetHeightCapa(this.hija);
	alturapadre=heightCapa(this.padre);
	top=topCapa(this.hija);

	//comprobamos si estamos llegando al final
	var porcion=Math.round(alturahijo*porcentaje/100);
    
	if (top+alturahijo-alturapadre<=porcion && valor<0)
	{	
		this.llegaPorcentaje(v,i);
		return;
	}
	

	if ( top>= -porcion && valor>0)
	{
	
		this.llegaPorcentaje(v,i);
		return;
	
	}

	if (top<0 && valor>0)
		cambiarTopCapa(this.hija,top + valor);
	
	if (valor<0 && top>=alturapadre-alturahijo)
		cambiarTopCapa(this.hija,top + valor);	
}

ScrollVer.prototype.desplazamientoNuevo = function(valor,intervalo,porcentaje,v,i)
{
	if (  valor==0 || intervalo==0 || porcentaje==0 || v==0 || i==0) return;
	
	clearInterval(this.TIMERID1);
	
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento(valor,porcentaje,v,i)};
	this.TIMERID1 = setInterval(funcion,intervalo);
}

ScrollVer.prototype.desplazar = function(valor,intervalo,espera,nuevoValor,nuevoIntervalo,porcentaje,v,i)
{
	if (  valor==0 || intervalo==0 || nuevoValor==0 || nuevoIntervalo==0 || porcentaje==0 || v==0 || i==0) return;
		
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento(valor,porcentaje,v,i)};
	var funcion2 = function () {thisobj.desplazamientoNuevo(nuevoValor,nuevoIntervalo,porcentaje,v,i)};
	this.TIMERID1 = setInterval(funcion,intervalo);
	this.TIMERID2 = setTimeout(funcion2,espera);
}

ScrollVer.prototype.llegaPorcentaje = function(v,i)
{
	clearInterval(this.TIMERID1);
	clearTimeout(this.TIMERID2);

	var thisobj=this;
	var funcion = function () {thisobj.desplazamientoFinal(v)};
	this.TIMERID1 = setInterval(funcion,i);
}

ScrollVer.prototype.desplazamientoFinal = function(v)
{
	var alturahijo;
	var alturapadre;
	var top;
	
	alturahijo=offsetHeightCapa(this.hija);
	alturapadre=heightCapa(this.padre);
	top=topCapa(this.hija);

	if (top<0 && v>0)
	{
		cambiarTopCapa(this.hija,top + v);
		return;
	}
	if (v<0 && top>=alturapadre-alturahijo)
	{
		cambiarTopCapa(this.hija,top + v);
		return;
	}
	
	//si llegamos aqui es que alcanzamos el final
	clearInterval(this.TIMERID1);
}

ScrollVer.prototype.cambiarDesplazamiento = function(valor,intervalo,porcentaje,v,i)
{
	if (  valor==0 || intervalo==0 || porcentaje==0 || v==0 || i==0) return;
	
	clearInterval(this.TIMERID1);
	clearTimeout(this.TIMERID2);
	
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento(valor,porcentaje,v,i)};
	this.TIMERID1 = setInterval(funcion,intervalo);

}



ScrollVer.prototype.parar = function()
{
	clearInterval(this.TIMERID1);
	clearTimeout(this.TIMERID2);
}


//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase BucleHor
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Implementa un bucle Horizontal. El texto se podra desplazar de izquierda a derecha y podremos
// controlar tanto el número de pixeles que se mueven de cada vez así como cada cuanto tiempo se 
// realizara el movimiento. También se podra parar en cualquier momento y volverlo a arrancar.
//
// METODOS:
//
// ---------- BubleHor(padre,hija,valor,intervalo)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padre:	una cadena con el identificador de la capa padre.
//		hija:	una cadena con el identificador de la capa hija.
//		valor:	el numero de pixeles que se desplazara el bucle de cada vez (con un valor negativo se 
//				desplaza hacia arriba.
//		intervalo:	cada cuanto tiempo en milisegundos se realizara el desplazamiento
//
// ---------- bucle()
// Este método se debe llamar una vez que hemos definido las capas y pone el bucle en funcionamiento
// con los valores dados al constructor
//
// ---------- pararBucle()
// Este metodo hace que se pare el movimiento del bucle
//
// ---------- reanudarBucle(valor,intervalo)
// Con este metodo reanudamos el funcionamiento del bucle con nuevos valores para valor e intervalo
// No es necesario que el bucle este parado para realizar la llamada.
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var b = new BucleHor("Layer1","Layer2",-10,50); 
// Despues de definir las capas haremos una llamada a la funcion bucle para
// comenzar el movimiento
//		b.bucle()
// Se pueden asociar las funciones pararBucle() y reanudarBucle() a diferentos eventos
// con llamadas de la siguiente forma
// 		b.pararBucle();		b.reanudarBucle(10,100);

// constructor de la clase
function BucleHor(padre,hija,valor,intervalo)
{
	this.padre=padre;
	this.hija=hija;
	this.valor=valor;
	this.intervalo=intervalo;
	this.TIMERID1=0;

}


BucleHor.prototype.desplazamiento = function ()
{
	var anchohijo;
	var anchopadre;
	var izquierda;
	
	anchohijo=offsetWidthCapa(this.hija);
	anchopadre=widthCapa(this.padre);
	izquierda=leftCapa(this.hija);
	
	if (this.valor < 0 && izquierda<=-anchohijo)
	{	
		cambiarLeftCapa(this.hija,anchopadre)
		return;
	}
	if (this.valor > 0 && izquierda>=anchopadre)
	{	
		cambiarLeftCapa(this.hija,-anchohijo);
		return;
	}
	
	cambiarLeftCapa(this.hija,izquierda + this.valor);
}

//funcion que se llama para arrancar el bucle
BucleHor.prototype.bucle = function ()
{
	
	if (this.valor==0 || this.intervalo==0) return;
		
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento()};
	this.TIMERID1 = setInterval(funcion,this.intervalo);

}

BucleHor.prototype.pararBucle = function()
{
	clearInterval(this.TIMERID1);
}

BucleHor.prototype.reanudarBucle = function(valor,intervalo)
{
	clearInterval(this.TIMERID1);
	this.valor=valor;
	this.intervalo=intervalo;
	this.bucle();
}



//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//										clase BucleVer
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
// OBJETIVO:
//
// Implementa un bucle vertical. El texto se podra desplazar de arriba a abajo o viceversa y podremos
// controlar tanto el número de pixeles que se mueven de cada vez así como cada cuanto tiempo se 
// realizara el movimiento. También se podra parar en cualquier momento y volverlo a arrancar.
//
// METODOS:
//
// ---------- BubleVer(padre,hija,valor,intervalo)
// Este es el constructor de la clase y tiene los siguientes parametros:
// 		padre:	una cadena con el identificador de la capa padre.
//		hija:	una cadena con el identificador de la capa hija.
//		valor:	el numero de pixeles que se desplazara el bucle de cada vez (con un valor negativo se 
//				desplaza hacia arriba.
//		intervalo:	cada cuanto tiempo en milisegundos se realizara el desplazamiento
//
// ---------- bucle()
// Este método se debe llamar una vez que hemos definido las capas y pone el bucle en funcionamiento
// con los valores dados al constructor
//
// ---------- pararBucle()
// Este metodo hace que se pare el movimiento del bucle
//
// ---------- reanudarBucle(valor,intervalo)
// Con este metodo reanudamos el funcionamiento del bucle con nuevos valores para valor e intervalo
// No es necesario que el bucle este parado para realizar la llamada.
//
// EJEMPLO DE FUNCIONAMIENTO:
//
// En primer lugar deberemos crear un objeto de la clase con la llamada al constructor
// 		var b = new BucleVer("Layer1","Layer2",-10,50); 
// Despues de definir las capas haremos una llamada a la funcion bucle para
// comenzar el movimiento
//		b.bucle()
// Se pueden asociar las funciones pararBucle() y reanudarBucle() a diferentos eventos
// con llamadas de la siguiente forma
// 		b.pararBucle();		b.reanudarBucle(10,100);

//constructor de la clase
function BucleVer(padre,hija,valor,intervalo)
{
	this.padre=padre;
	this.hija=hija;
	this.valor=valor;
	this.intervalo=intervalo;
	this.TIMERID1=0;

}

BucleVer.prototype.desplazamiento = function ()
{
	var alturahijo;
	var alturapadre;
	var top;
	
	alturahijo=offsetHeightCapa(this.hija);
	alturapadre=heightCapa(this.padre);
	top=topCapa(this.hija);
	
	if (this.valor < 0 && top<=-alturahijo)  
	{	
		cambiarTopCapa(this.hija,alturapadre)
		return;
	}
	if (this.valor > 0 && top>=alturapadre)
	{	
		cambiarTopCapa(this.hija,-alturahijo);
		return;
	}
	
	cambiarTopCapa(this.hija,top + this.valor);
}

//funcion que se llama para arrancar el bucle
BucleVer.prototype.bucle = function ()
{
	
	if (this.valor==0 || this.intervalo==0) return;
		
	var thisobj=this;
	var funcion = function () {thisobj.desplazamiento()};
	this.TIMERID1 = setInterval(funcion,this.intervalo);

}

BucleVer.prototype.pararBucle = function()
{
	clearInterval(this.TIMERID1);
}

BucleVer.prototype.reanudarBucle = function(valor,intervalo)
{
	clearInterval(this.TIMERID1);
	this.valor=valor;
	this.intervalo=intervalo;
	this.bucle();
}