// Codigo JavaScript para hacer scroll
var ParaScroll = false;
var IncScroll = 0;
var CapaScroll = 0;  // Indica la capa a scrollar: 1..n: indice en ScrollCapas[] (0)= ninguna
var DestinoScroll = -1;  // Cuando es >= 0 se activa el scroll automatico hasta llegar a esta coordenada Y

var ManejadorEventos = "";  // Funcion que se llama para manejar eventos de raton

var ScrollOrigenY = [0, 0, 0, 0, 0, 0, 0, 0, 0];  // Posicion Y original del posicionador de la barra (la X debe ser siempre = 0)

// Inicializacion del scroll. Es necesario llamar a esta funcion en el onLoad() del modulo
// donde se usa NewScroll.
// Si recalcula=true se recalculan automaticamente las alturas de las capas de scroll en funcion de
// su contenido.
function IniciaScroll(recalcula)
{
	var n, obj, x, y, w, h;

	if(recalcula) {
		for(n = 0; n < ScrollCapas.length; n++) {
			// Obtenemos la altura total del texto en el scroll
			obj = ObjetoCapa(ScrollCapas[n]);
			if(obj) {
				if(obj.scrollHeight) ScrollAltoTotal[n] = obj.scrollHeight + 20;
				else if(obj.offsetHeight) ScrollAltoTotal[n] = obj.offsetHeight + 20;
				else if(obj.document && obj.document.height) ScrollAltoTotal[n] = obj.document.height + 20;
				else ScrollAltoTotal[n] = 'auto';
			}
		}
	}

	for(n = 0; n < ScrollCapas.length; n++) {
		IniciaCapa(ScrollCapas[n], ScrollX[n], ScrollY[n], ScrollAncho[n], ScrollAltoTotal[n], 0, 0, ScrollAncho[n], ScrollAlto[n]);
		// Obtenemos las dimensiones del posicionador de la barra de scroll
		obj = ObjetoCapa(ScrollBarraPos[n]);
		if(obj) {
			if(obj.scrollHeight) {
				h = obj.scrollHeight;
				w = obj.scrollWidth;
			} else if(obj.offsetHeight) {
				h = obj.offsetHeight;
				w = obj.offsetWidth;
			} else if(obj.document && obj.document.height) {
				h = obj.document.height;
				w = obj.document.width;
			}
			// Las coordenadas relativas
			ScrollOrigenY[n] = (obj.top)?  obj.top : obj.offsetTop;
			IniciaCapa(ScrollBarraPos[n], 0, ScrollOrigenY[n], w, h);
		}

		if(ScrollAltoTotal[n] == 'auto') ScrollAltoTotal[n] = document.getElementById(ScrollCapas[n]).scrollHeight;
	}
	// Captura eventos del raton
	obj = window;  //ObjetoCapa(ScrollBarraPos[n]);
	if(obj) {
		obj.document.onmousemove = ArrastraScrollWin;
		obj.document.onmousedown = ArrastraScrollWin;
		obj.document.onmouseup = ArrastraScrollWin;
		obj.document.onmouseout = ArrastraScrollWin;
		if(document.captureEvents) {
			obj.document.captureEvents(Event.MOUSEMOVE | Event.MOUSEDOWN | Event.MOUSEUP | Event.MOUSEOUT);
		}
	}

	setInterval("TemporizaScroll()", 100);
}

// Manejador de eventos de raton para controlar la barra de scroll
var ArrastrandoPos = -1;
var OrigenPosY = 0;
var OrigenRataY = 0;
function ArrastraScrollWin(ev)
{
	var obj, obj2, n, tot, px, py, x1, y1, y2, w, h, x, y;
	var result, ss;

	if(ev) { // En Netscape se pasa ev como parametro
		px = ev.pageX;
		py = ev.pageY;
	} else { // En otros, hay que leer el objeto "event"
		ev = event;
		px = ev.x + document.body.scrollLeft; // ev.screenX;
		py = ev.y + document.body.scrollTop; //ev.screenY;
	}

	result = true;

	if(ev.type == "mousemove") {
		if(ArrastrandoPos >= 0) {
			y = OrigenPosY + py - OrigenRataY;
			y1 = ScrollOrigenY[ArrastrandoPos];
			h = ScrollBarraH[ArrastrandoPos];
			if (y < y1) y = y1;
			if (y > y1 + h) y = y1 + h;

			// Movemos el posicionador de la barra
			PosicionaCapaY(ScrollBarraPos[ArrastrandoPos], y);

			// Movemos la capa de scroll
			tot = ScrollAltoTotal[ArrastrandoPos];
			h = ScrollAlto[ArrastrandoPos];
			y = ((y - ScrollOrigenY[ArrastrandoPos]) * (tot - h)) / ScrollBarraH[ArrastrandoPos];
			x1 = CapaX(ScrollCapas[ArrastrandoPos]);
			AnimacionCapa(ScrollCapas[ArrastrandoPos], x1, ScrollY[ArrastrandoPos]-y, 0, "c", "");

			result = false;
		}
	} else if(ev.type == "mousedown") {
		tot = ScrollBarraPos.length;
		for(n=0; n < tot; n++) {
			obj = ObjetoCapa(ScrollBarraPos[n]);
			ss = "";
			obj2 = obj;
			if(obj2.style) ss = obj2.style.visibility;
			else ss = obj2.visibility;
			if(ss.length == 0)
				if(obj.parentElement) {
					obj2 = obj.parentElement;
					if(obj2.style) ss = obj2.style.visibility;
					else ss = obj2.visibility;
				}
				if(ss.indexOf("hidde") == -1) {
					if(obj.pageX) {
						x1 = obj.pageX;
						y1 = obj.pageY;
					} else {
						x1 = y1 = 0;
						while(obj) {
							x1 += obj.offsetLeft;
							y1 += obj.offsetTop;
							obj = obj.offsetParent;
						}
					}
					y2 = y1;
					y = CapaY(ScrollBarraPos[n]);
					y1 -= y - ScrollOrigenY[n];
					w = CapaAncho(ScrollBarraPos[n]);
					h = CapaAlto(ScrollBarraPos[n]);

					if(px >= x1  &&  px <= (x1 + w) && py >= y1  &&  py <= (y1 + ScrollBarraH[n] + h)) {
					if(py >= y2  &&  py <= (y2 + h)) {  // Estamos pillando el posicionador?
						ArrastrandoPos = n;
						OrigenPosY = y;
						OrigenRataY = py;
						break;
					} else { // Si no, sera un salto arriba o abajo
						if(py < y2)   // Pagina arriba
							ScrollPaginaArriba(n+1);
						else          // Pagina abajo
							ScrollPaginaAbajo(n+1);
					}
					result = false;
				}
			}
		}
	} else if(ev.type == "mouseup") {
		ArrastrandoPos = -1;
	}

	if(ManejadorEventos != "") {
		var ss = ManejadorEventos +"(\""+ ev.type +"\", "+ px +", "+ py +");";
		eval(ss);
	}

	if(document.layers) {
		test = routeEvent(ev);
		if(test) return true;
		return result;
	}

	return false;
}

// Activa un scroll
//   scod indica la capa a activar y como, es una cadena de 2 caracteres. El primero es un
//      número (1..n) que indica la capa de scroll a activar
//    mientras que el segundo caracter puede ser:
//      "u"  -> scroll up
//      "d"  -> scroll down
function ActivarScroll(scod)
{
var s1, s1;

	if(DestinoScroll >= 0)
	  return;
  s1 = scod.substr(0, 1);  // El indice de scroll
  s2 = scod.substr(1, 1);
	ParaScroll = false;
	CapaScroll = s1 / 1;
	if(s2 == "u")
	  IncScroll = 2;
	else
		IncScroll = -2;
}

// Va a una posicion concreta de Scroll (coordenada Y) y se detiene en ella
//   ncapa:    No. capa de scrol (1..n)
//   cy:			 coordenada final Y
function AutoScroll(ncapa, cy, instantaneo)
{
var y1, scapa;

	if(DestinoScroll >= 0)
	  return;

	if(instantaneo) {
		scapa = ScrollCapas[ncapa - 1];
		y1 = ScrollY[ncapa-1]-cy;
	  PosicionaCapaY(scapa, y1);
		RecortaCapa(scapa, 0, cy, ScrollAncho[ncapa-1], ScrollAlto[ncapa-1]+cy);
		y1 = ((ScrollY[ncapa-1] - y1) * ScrollBarraH[ncapa - 1]) / (ScrollAltoTotal[ncapa-1] - ScrollAlto[ncapa-1]);
		PosicionaCapaY(ScrollBarraPos[ncapa-1], ScrollOrigenY[ncapa-1] + y1);
	}
	else {
		DestinoScroll = cy;
		CapaScroll = ncapa;
		scapa = ScrollCapas[CapaScroll-1];
		ParaScroll = false;
	  y1 = CapaY(scapa);
		if(y1 < -DestinoScroll+ScrollY[CapaScroll-1]) {
		  IncScroll = 2;
		}
		else {
		  IncScroll = -2;
		}
	}
}

// Sube una pagina arriba
function ScrollPaginaArriba(ncapa)
{
var cy;

	if(IncScroll != 0)
	  return;
	cy = ScrollY[ncapa-1] - CapaY(ScrollCapas[ncapa-1]);
	cy -= ScrollAlto[ncapa-1] - 24;
	if(cy < 0)
	  cy = 0;
	AutoScroll(ncapa, cy);
	IncScroll *= 10;  // Para que vaya rapidillo
}

// Baja una pagina abajo
function ScrollPaginaAbajo(ncapa)
{
var cy;

	if(IncScroll != 0)
	  return;
	var tot = ScrollAltoTotal[ncapa-1] - ScrollAlto[ncapa-1];

	cy = ScrollY[ncapa-1] - CapaY(ScrollCapas[ncapa-1]);
	cy += ScrollAlto[ncapa-1] - 24;
	if(cy > tot)
	  cy = tot;
	AutoScroll(ncapa, cy);
	IncScroll *= 10;  // Para que vaya rapidillo
}

// Para deactivar el scroll
function DesactivarScroll(scod)
{
	if(DestinoScroll >= 0)
	  return;
	ParaScroll = true;
}

function TemporizaScroll()
{
	try {
var n, x1, y1, x2, y2, topey, rx, ry, gy1, gy2;
var h, toth;

	// Programación de la capa de scroll
  if(CapaScroll > 0  &&  IncScroll != 0) {
    var scapa = ScrollCapas[CapaScroll-1];
    x1 = CapaX(scapa);
    gy1 = y1 = CapaY(scapa);

    y1 += IncScroll;

		toth = ScrollAltoTotal[CapaScroll-1];
		h = ScrollAlto[CapaScroll-1];
	  topey = ScrollY[CapaScroll-1] - toth + h;
	  if(y1 < topey)	    y1 = topey;

	  y2 = ScrollY[CapaScroll-1];

	  if(y1 > y2)	    y1 = y2;

		// Si esta activado el scroll automatico...
		if(DestinoScroll >= 0) {
		  gy2 = y1;
		  if(gy1 > gy2) {
		    n = gy1;
				gy1 = gy2;
				gy2 = n;
		  }
		  if(((-DestinoScroll) >= (gy1-y2)  &&  (-DestinoScroll) <= (gy2-y2))
			   || y1 >= y2  ||  y1 <= topey) {
				if(y1 >= y2)
				  y1 = y2;
				else if(y1 <= topey)
				  y1 = topey;
				else
				  y1 = -DestinoScroll + y2;
			  ParaScroll = true;
			  DestinoScroll = -1;
	    }
		}
		// Movemos la capa de scroll
    AnimacionCapa(scapa, x1, y1, 0, "c", "");
		// Movemos el posicionador de la barra
		y1 = ((y2 - y1) * ScrollBarraH[CapaScroll - 1]) / (toth - h);
		PosicionaCapaY(ScrollBarraPos[CapaScroll-1], ScrollOrigenY[CapaScroll-1] + y1);

    // Actualizamos los parámetros del scroll
    if(ParaScroll) {
      // IncScroll -= IncScroll / 3;
			IncScroll /= 2;
			//IncScroll = (IncScroll > 0)?  Math.floor(IncScroll) : Math.ceil(IncScroll);
			if(Math.abs(IncScroll) < 1)
			  IncScroll = 0;
		}
    else {
	    IncScroll += (IncScroll > 0)?  1 : -1;
 	    // IncScroll = (IncScroll > 12)?  12 : (IncScroll < -12)?  -12 : IncScroll;
		  IncScroll = (IncScroll > 20)?  20 : (IncScroll < -20)?  -20 : IncScroll;
    }
  }

  } catch(err) {
  	// alert(err);
  }
}

// Reinicia una capa de scroll a su posición inicial
function ReiniciaScroll(ind)
{
	AnimacionCapa(ScrollCapas[ind-1], ScrollX[ind-1], ScrollY[ind-1], 0, "c", "");
	PosicionaCapaY(ScrollBarraPos[ind-1], ScrollOrigenY[ind-1]);
}

document.write("<style type='text/css'>\n");
document.write("<!--\n");

{
var n, sestilo;

  for(n=0; n < ScrollCapas.length; n++) {
	  sestilo = "#"+ScrollCapas[n] + " {position:absolute; left:"+ScrollX[n]+"px; top:"+
		                ScrollY[n]+"px; width:"+ScrollAncho[n]+"px; height:"+ScrollAltoTotal[n]+
										"px; clip:rect(0,"+ScrollAncho[n]+","+ScrollAlto[n]+",0);";
	  if(!ScrollVisible[n])
		sestilo += "visibility:hidden;";
	  sestilo += OtrosEstilos[n];
	  sestilo += "}\n";
	  document.write(sestilo);
	}
}

document.write("-->\n");
document.write("</style>\n");