/*==========================================================================
FUNCION: 	oMovil, objeto movil
ARGS:		idCapa: ID del bloque DIV que forma el objeto
			px0, py0: posición inicial del objeto;
			px1, py1: posición final del objeto
			tiempo:	tiempo que emeplea en el movimiento:
			fntmov: función de usuario realizar el movimiento (opcional)	
DEVUELVE:	Nada
DESCRIP.:	Construye un objeto que podrá moverse por la ventana. Los incrementos de
			las coordenadas X e Y se calculan en base a aproximadamente 24 actualizaciones 
			por segundo.
PROPIEDADES:
capa:		Objeto javascript para el bloque DIV que se moverá por la pantalla
px0, py0:	coordenadas inciales del objeto.
pxt, pyt:	coordenadas actuales del bloque u objeto móvil
px1, py1:	coordenadas finales del móvil.
tiempo:		tiempo que debe durar el movimiento
esFinal:	valor booleano, true indica que ha finalizado el movimiento
visible:	lógico, true deja el objeto visible al final del movimiento, false lo oculta.
incx, incy:	valores de los incrementos de las coordenadas vertical y horizontal
			para cada uno de los pasos que forman el movimiento
METODOS
mover:		función que calcula las coordenadas en cada instante del movimiento
situar:		coloca el movil en una posiciçón dada por dos coordenadas
reset:		reinicializa el movimiento a su posición inicial 
ponX, ponY:	actualiza los valores de las coordenadas actuales
leeX, leeY:	lee las coordenadas actuales 

=============================================================================*/
function oMovil (idcapa, px0, py0, px1, py1, tiempo, visfin, fntmov)
{
this.capa = objHtml(idcapa);
this.px0 = px0;
this.py0 = py0;
this.pxt = this.px0;
this.pyt = this.py0;
this.px1 = px1;
this.py1 = py1;
this.tiempo = tiempo*100;
this.esFinal = false;
this.visible = visfin;
this.incx = (px1-px0)*50/this.tiempo;
this.incy = (py1-py0)*50/this.tiempo;
if (fntmov)
	this.mover = eval(fntmov);
	
//Definiciones de los métodos del objeto oMovil	
/*==========================================================================
FUNCION: 	oMovil_reset, miembro del objeto oMovil
ARGS:		ninguno
DEVUELVE:	nada.
DESCRIP.:	Reinicia el movimiento a sus condiciones originales.
=============================================================================*/
function oMovil_reset()
{
this.pxt = this.px0;
this.pyt = this.py0;
this.esFinal = false;
this.incx = (this.px1-this.px0)*45/this.tiempo
this.incy = (this.py1-this.py0)*45/this.tiempo;
mostrarBlq(this.capa, true);
}

/*==========================================================================
FUNCION: 	oMovil_mover, miembro del objeto oMovil
ARGS:		ninguno
DEVUELVE:	boolean, verdad si alcanzó el punto final del movimiento.
DESCRIP.:	Calcula la siguiente posición del bloque que se está moviendo, simplemente 
			suma a la coordenada X el incremento X y a la Y el incremento Y. Esta función 
			puede ser sustituida por una función de usuario que debe ir calculando los 
			sucesivos valores de las coordenadas y devolver un valor en el mismo sentido 
			que lo hace ésta.
=============================================================================*/

function oMovil_mover()
{
this.pxt += this.incx;
this.pyt += this.incy;
if (Math.abs(this.px1-this.pxt) <= Math.abs(this.incx)) this.pxt = this.px1;
if (Math.abs(this.py1-this.pyt) <= Math.abs(this.incy)) this.pyt = this.py1;
this.situar();
this.esFinal = (this.px1 == this.pxt) && (this.py1 == this.pyt);
}

/*==========================================================================
FUNCION: 	oMovil_situar, miembro del objeto oMovil
ARGS:		coordendas x y del punto donde se quiere seituar el objeto
DEVUELVE:	nada
DESCRIP.:	Coloca el bloque movil en la posición indicada por los argumentos. Si estos no 
			existen se usan las coordenas actuales del objeto, almacenadas en px0 y py0.
=============================================================================*/
function oMovil_situar(x0, y0)
{
if (arguments.length < 2)
	{
	x0 = this.pxt;
	y0 = this.pyt;
	}
if (miNavegador.standard || (miNavegador.IE && miNavegador.version >=4))
	{
	this.capa.style.top = y0+'px';
	this.capa.style.left = x0+'px';
	}
else
	{
	this.capa.left = x0;
	this.capa.top = y0;
	}
}
oMovil.prototype.mover = oMovil_mover;
oMovil.prototype.situar = oMovil_situar;
oMovil.prototype.ponX = new Function("x", "this.pxt = x");
oMovil.prototype.ponY = new Function("y", "this.pyt = y");
oMovil.prototype.leeX = new Function("return this.pxt");
oMovil.prototype.leeY = new Function("return this.pyt");
oMovil.prototype.reset = oMovil_reset;
}
//Fin del objeto oMovil
/*==================================================================================
FUNCION: 	oAnimacion, objeto.
ARGS:		Objetos del tipo oMovil que forman parte de la animación
DEVUELVE:	nada
DESCRIP.:	Se encarga de mover por la pantalla los objetos que contiene y si posee 
			objetos oAnimación enlazados también los mueve.
PROPIEDADES
moviles:	lista de objetos oMovil
enlazadas:	oAnimacion enlazada, o sea, animación siguiente
retraso:	número de milisegundos que debe retrasrse el inicio de esta animación
METODOS :
iniciar:	inicia la animación
enlazar:	enlaza una nueva animación
=============================================================================*/
function oAnimacion()
{
var ind;
this.moviles = new Array();
this.enlazadas = null;
this.retraso = 0;
for (ind=0; ind < arguments.length; ind++)
	this.moviles[ind] = arguments[ind];


oAnimacion.prototype.iniciar = oAnimacion_iniciar;
oAnimacion.prototype.enlazar = oAnimacion_enlazar;
oAnimacion.prototype.reset = oAnimacion_reset;

/*==========================================================================
FUNCION: 	oAnimacion_reset, miembro del objeto oAnimacion (reset)
ARGS:		no.
DEVUELVE:	nada
DESCRIP.:	Reiniciliza los móviles de la animación
=============================================================================*/
function oAnimacion_reset()
{
var ind;
for (ind in this.moviles)
	this.moviles[ind].reset();
}

/*==========================================================================
FUNCION: 	oanimacion_enlazar, miembro del objeto oAnimacion
ARGS:		objeto oAnimacion a enlazar con el actual.
			valor lógico: ture el nuevo movto. comienza donde termina el actual
DEVUELVE:	nada
DESCRIP.:	Engancha a este objeto oAnimacion de manera que cuando este termine
			de actuar comienza el señalado por esta propiedad. Si se ha indicado
			true en el segundo argumento del constructor el nuevo movimiento comienza
			donde finaliza la actual.
=============================================================================*/
function oAnimacion_enlazar(idObjanim, total, retraso)
{
var objanim=eval(idObjanim);
var ind1, ind2;
if (retraso) objanim.retraso = retraso;
if (total==true)
	{
	for (ind1 in objanim.moviles)
		{
		for (ind2 in this.moviles)
			{
			if (objanim.moviles[ind1].capa.id == this.moviles[ind2].capa.id)
				{
				objanim.moviles[ind1].px0 =  this.moviles[ind2].px1;
				objanim.moviles[ind1].py0 =  this.moviles[ind2].py1;
				objanim.moviles[ind1].reset();
				}
			}
		}
	}	
this.enlazadas = idObjanim;
}

/*==========================================================================
FUNCION: 	oAnimacion_iniciar(), miembro del objeto oAnimacion
ARGS:		el identificador del objeto y un retraso para el inicio del movimiento
DEVUELVE:	nada
DESCRIP.:	Funcion llamada por el evento setTimeout( ) que va moviendo los objetos que 
			forman la animación, cada uno con su propia función de movimiento. Cuando ha
			movido todos los objetos que contiene llama a la animación que tenga enlazada
			si es que existe. Util para movimientos encadenados de una misma capa.
=============================================================================*/
function oAnimacion_iniciar(arg, retraso)
{
var ind; fin=true; finparc=false; ret = 0;
var obj = eval(arg);

if (retraso>0)
	{
	setTimeout(arg+".iniciar('"+arg+"')", retraso)
	return
	}
for (ind in obj.moviles)
	{		
	if(obj.moviles[ind].esFinal) continue;
	if (obj.moviles[ind].capa.actual == null)
		obj.moviles[ind].capa.actual = arg;
	else 
		if (obj.moviles[ind].capa.actual != arg) 
			{
			fin = false;
			continue;
			}
	obj.moviles[ind].mover(); 
	finparc = obj.moviles[ind].esFinal;
	if (finparc) 
		{
		obj.moviles[ind].capa.actual = null;
		mostrarBlq(obj.moviles[ind].capa, obj.moviles[ind].visible);
		}
	fin = finparc && fin;
	}
if (!fin)
	setTimeout(arg+".iniciar('"+arg+"')", 50)
else 
    {
	if (obj.enlazadas != null)
		{
		arg = obj.enlazadas;
		eval(arg+'.reset()');
		ret = eval(arg+'.retraso');
		setTimeout(arg+".iniciar('"+arg+"')", 50+ret)
		}
	}	
 }
}//Fin del objeto oAnimacion


/*=============================================================================
Un uso típico sería en una función algo así como
function iniAnimaciones()
{
movil1 = new oMovil('capa1', 10, 100, 300, 500, 700)
movil1.situar();
movil2 = new oMovil('capa2', 410, 100, 10, 500, 700)
movil2.situar();
animacion1 = new oAnimacion(movil1, movil2)
}
que sería vinculada al evento que deba iniciar el movimiento, al cargar la página<br>
(<body onload=iniAnimaciones()>), en un click (< href="#" onclick="iniAnimaciones()") o cualquier otro.
===============================================================================*/