if(document.images&&document.createElement&&document.getElementById){ 
    document.writeln('<style type="text/css">'); 
    document.writeln('img.shiftzoom { visibility: hidden; }'); 
    document.writeln('<\/style>'); 
}
 
shiftzoom.defaultCurpath = 'images/cursors/';

shiftzoom.defaultOverview = false;
shiftzoom.defaultFading = false;


/**
 Añade una imagen al visualizador de imágenes.
*/
function addImagenVisualizador (img, lowimg)
{
    shiftzoom.add (img, {
            showcoords: false,
            zoom: 0,
            buttons: false
            });
}


/* Redefinición de varias funciones para captar evento de actualización de coordenadas */

var __oldZoomIn = shiftzoom._zoomIn;
shiftzoom._zoomIn = function(id,ct,st,sw,ew,sh,eh,sx,ex,sy,ey,nz) {
	__oldZoomIn(id,ct,st,sw,ew,sh,eh,sx,ex,sy,ey,nz);
	actualizarCoordenadas();
};
var __oldZoomOut = shiftzoom._zoomOut;
shiftzoom._zoomOut = function(id,rm,ct,st,sw,ew,sh,eh,sx,ex,sy,ey,nz) {
	__oldZoomOut(id,rm,ct,st,sw,ew,sh,eh,sx,ex,sy,ey,nz);
	actualizarCoordenadas();
};
var __oldStopZoom = shiftzoom._stopZoom;
shiftzoom._stopZoom = function() {
	__oldStopZoom();
	actualizarCoordenadas();
};
var __oldZoomKey = shiftzoom._zoomKey;
shiftzoom._zoomKey = function(d,ct,ww,st,sw,ew,sh,eh,sx,ex,sy,ey,nz) {
	__oldZoomKey(d,ct,ww,st,sw,ew,sh,eh,sx,ex,sy,ey,nz);
	//Guardamos el valor del zoom en la cookie
	var zoom = getZoomVisualizador ($('imagezoom'));
	setPrefZoom (zoom);
	actualizarCoordenadas();
};
var __oldPanKey = shiftzoom._panKey;
shiftzoom._panKey = function(h,v,s,a) {
	__oldPanKey(h,v,s,a);
	actualizarCoordenadas();
};
var __oldWhilePan = shiftzoom._whilePan;
shiftzoom._whilePan = function(e) {
	__oldWhilePan(e);
	actualizarCoordenadas();
};
var __oldStopPan = shiftzoom._stopPan;
shiftzoom._stopPan = function() {
	__oldStopPan();
	actualizarCoordenadas();
};
var __oldWhileMove = shiftzoom._whileMove;
shiftzoom._whileMove = function(e) {
	__oldWhileMove(e);
	actualizarCoordenadas();
};
var __oldStopMove = shiftzoom._stopMove;
shiftzoom._stopMove = function() {
	__oldStopMove();
	actualizarCoordenadas();
};

var delay = 1200;
var __oldKenburns = shiftzoom.kenburns;
shiftzoom.kenburns = function(img,x,y,z,p,s,d,b,a) {
	__oldKenburns(img,x,y,z,p,s,d,b,a);
	actualizarCoordenadas();
	if(typeof(d)==="number") {d=Math.max(1,Math.min(100,parseInt(d)));}else {d=30;}
	if (img.timer) {
		window.setTimeout ("actualizarCoordenadas();", d + delay);
		delay = 250;
		window.setTimeout ("actualizarCoordenadas();", 700); //segundo timeout para que actualice bien en IE6
	}
};
var __oldStop = shiftzoom.stop;
shiftzoom.stop = function() {
	__oldStop();
	actualizarCoordenadas();
};
var __oldZooming = shiftzoom.zooming;
shiftzoom.zooming = function(img,v) {
	__oldZooming(img,v);
	actualizarCoordenadas();
};



/**
 Añade una imagen al visualizador de imágenes, con un determinado
 zoom y posición.
*/
function addImagenVisualizador (img, x, y, zoom)
{
    shiftzoom.add (img, {
            showcoords: false,
            zoom: zoom,
            xpos: x,
            ypos: y,
            buttons: false
            });
}

/**
 Quita la imagen del visualizador de imágenes.
*/
function removeImagenVisualizador (img)
{
	shiftzoom.remove (img, true);
}

/**
 Obtiene el zoom actual que tiene la imagen dentro del visualizador de imágenes.
*/
function getZoomVisualizador (img)
{
	var zoom = shiftzoom.get (img, "currentxyz").z;
	if (zoom > 0)
		return zoom;
	else return 0;
}

/**
 Obtiene la posición actual de la imagen dentro del visualizador de imágenes.
*/
function getPosicionVisualizador (img)
{
	var x = shiftzoom.get (img, "currentxyz").x;
	var y = shiftzoom.get (img, "currentxyz").y;
	return {x:x, y:y};
}

/**
 Obtiene la altura natural de la imagen pasada.
*/
function getNaturalHeight(img) {
    if( img.naturalHeight ) {
        return img.naturalHeight;
    } else {
        lgi = new Image();
        lgi.src = img.src;
        return lgi.height;
    }
}

/**
 Obtiene el ancho natural de la imagen pasada.
*/
function getNaturalWidth(img) {
    if( img.naturalWidth ) {
        return img.naturalWidth;
    } else {
        lgi = new Image();
        lgi.src = img.src;
        return lgi.width;
    }
}

/**
 Obtiene la posición vertical absoluta en pixeles, dentro de la ventana, 
 que tiene el objeto pasado. 
*/
function getPosicionAbsoluta(obj)
{
    var valueT = 0, valueL = 0;
    var position;
    var elementos = [];
    var i = 0;

	// Corrección para Internet Explorer. Cuando en Internet Explorer hay algún elemento padre, del elemento
	// a calcular su posición, con position 'relative', el método viewportOffset() no es capaz de calcular 
	// bien la posición absoluta del elemento, por lo que hay que poner dicho elemento como static para que
	// el cálculo sea correcto. Lo que hacemos con el siguiente bucle es poner todos los elementos relative
	// como static para calcular posición actual. Después se devolveran a su position original.
	if (Prototype.Browser.IE)
	{
	    var element = obj;
	    do 
	    {
			if (element.offsetParent && Element.getStyle(element.offsetParent, 'position') == 'relative') 
			{
				var elemento = element.offsetParent
				elementos[i++] = elemento; 
				$(elemento).setStyle ({position: 'static'});
			}
			
	    } while (element = element.offsetParent);
	}

	// Obtenemos la posición actual
	position = $(obj).viewportOffset();
	
	// Volvemos a poner todos los elementos padre que fuesen relativos como relativos
	if (Prototype.Browser.IE)
	{
		for (var i = 0; i < elementos.length; i++)
		{
			$(elementos[i]).setStyle ({position: 'relative'});
		}
	}
	
	// Devolvemos la posición actual del elemento
	return position;
}

// Anchura y altura minimas
var alturaMin = 400;
var anchuraMin = 400;

function getAlturaBodyIE6()
{
	var body = $('contenido');
	
	var quitarBordeSuperior = false;
	var quitarBordeInferior = false;
	
	// Para que el alto del body sea correcto debe tener un borde superior e inferior
	if (BrowserDetect.version >= 8) {
		var bodyBorder = body.getStyle ('border-top-width');
		if ((bodyBorder == null) || !bodyBorder || (bodyBorder.substring(0,1) == '0')) {
			body.setStyle ({
					borderTop: '1px solid white'
				});
			quitarBordeSuperior = true;
		}
		bodyBorder = body.getStyle ('border-bottom-width');
		if ((bodyBorder == null) || !bodyBorder || (bodyBorder.substring(0,1) == '0')) {
			body.setStyle ({
					borderBottom: '1px solid white'
				});
			quitarBordeInferior = true;
		}
	}

	// Altura del body
	bodyHeight = $(body).getHeight() + ($(body).viewportOffset().top * 2);

	// Se vuelve a quitar el borde ficticio que pusimos para el cálculo
	if (quitarBordeSuperior) {
		body.setStyle ({
				borderTopWidth: '0'
			});
	}
	if (quitarBordeInferior) {
		body.setStyle ({
				borderBottomWidth: '0'
			});
	}

	return bodyHeight;
}


/**
 Obtiene las dimensiones actuales que debe tener la imagen dentro del viewport
 en función del resto de elementos dentro de la ventana.
*/
function getDimensionesRelativas(imagen, viewport)
{
	// Obtenemos la altura de la ventana y la altura del documento
	var windowheight = getAlturaVentana();
    var htmlheight = getAlturaBody();
    if (Prototype.Browser.IE && (BrowserDetect.version == 6)) {
	    htmlheight = getAlturaBodyIE6();
	}

    var alturaVentana = 0;
    
    // Obtenemos el tamaño natural de la imagen
	var imgAltura = getNaturalHeight(imagen);
	var imgAnchura = getNaturalWidth(imagen);
	
	// A la altura de la página hay que quitarle la altura de todos los elementos que están por encima de la página,
	// incluidos también sus márgenes. Si estamos en pantalla completa, tambien mantendremos los elementos inferiores
	if (enPantallaCompleta()) 
	{
		alturaVentana = windowheight - (htmlheight - $(viewport).getHeight());
	} 
	else 
	{
		var posAbsoluta = getPosicionAbsoluta(viewport);
	    alturaVentana = windowheight - posAbsoluta.top;
	}

	// Visualizador no mas grande que imagen
	if (imgAltura < alturaVentana)  alturaVentana = imgAltura;
	
	// Obtenemos la anchura actual del viewport para calcular las
	// dimensiones de la imagen
	var anchuraVentana = $(viewport).getWidth();
	if (imgAnchura < anchuraVentana)
		anchuraVentana = imgAnchura;
	
    // Si la altura de la imagen es mayor que la anchura, calculamos la anchura en función de la altura y sino alrevés
    if (alturaVentana < anchuraVentana)
    {
    	// Cogemos como referencia la altura de la ventana porque es la menor de las dos medidas
	    var altura = alturaVentana;
	    if (altura < alturaMin)  altura = alturaMin;
    	var anchura = (altura * imgAnchura) / imgAltura;

		// Si la imagen es más ancha que alta, puede ser que se salga de la anchura de la ventana
		// y habría que reducir proporcionalmente, tanto la altura como la anchura
    	if (imgAltura < imgAnchura)
    	{
            if (anchura > anchuraVentana)
            {
                anchura = anchuraVentana;
                altura = (anchura * imgAltura) / imgAnchura;
            }
    	}
    }
    else
    {
    	// Cogemos como referencia la anchura de la imagen de la ventana porque es la menor
	    var anchura = anchuraVentana;
	    if (anchura < anchuraMin)  anchura = anchuraMin;
    	var altura = (anchura * imgAltura) / imgAnchura;
    	
    	// Si la imagen es más alta que ancha, puede ser que la altura calculada se salga de la altura de la
    	// ventana, por lo que habría que reducir proporcionalmente tanto la altura como la anchura 
		if (imgAltura > imgAnchura)
		{    	
            if (altura > alturaVentana)
            {
                altura = alturaVentana;
                anchura = (altura * imgAnchura) / imgAltura;
            }
		}
    }
    
    return {altura:altura, anchura:anchura};
}

var redimensionando = false;

/**
 Redimensiona la imagen dentro del visualizador, dependiendo del tamaño actual de la ventana,
 y de los elementos que contenga la misma.
*/
function redimensionarVisualizador (imagenId, viewportId)
{
	if (!redimensionando) {
		redimensionando = true;
		
	    // Obtenemos la imagen y el viewport que la contiene
		var imagen = $(imagenId);
		var viewport = $(viewportId);
		
		if (imagen != undefined && viewport != undefined)
		{
			// Obtenemos las dimensiones relativas que debe tener la imagen dentro de la ventana
			var dimensiones = getDimensionesRelativas (imagen, viewport);
			
			// Si la altura y la anchura es mayor que 0 ponemos dichas dimensiones a la imagen
			if (dimensiones && dimensiones.altura > 0 && dimensiones.anchura > 0)
			{
				changeSize (imagen, viewport, dimensiones.altura, dimensiones.anchura);

				// Redimensionamos la caja de detalle asociada, si es que tiene, para que llegue hasta 
				// la misma altura que el viewport. Para ello calculamos la posición más baja en la que
				// se encuentra el visualizador
				var posAbsolutaViewport = getPosicionAbsoluta(viewport);
				redimensionarCajaDetalle (dimensiones.altura + posAbsolutaViewport.top);
			}
		}
		
		redimensionando = false;
	}
}

/**
 Redimensiona la caja de detalle asociadada al visualizador de imágenes para que su posición más baja
 coincida. En el caso en el que el contenido de la caja de detalle sea superior al tamaño se crearía
 una barra de scroll para poder verlo completo.
*/
function redimensionarCajaDetalle (bottomViewport)
{
	var minHeight = 400;
	
	// Comprobamos que se haya inicializado una caja de detalle y que esté visible para
	// redimensionarla.
	if (cajaDetalleId != undefined && cajaDetalleId != null && cajaDetalleId != '' && $(cajaDetalleId).visible())
	{
		// Tomamos la posición absoluta del detalle para restársela a la posición baja del viewport.
		// De esta forma obtendríamos el tamaño que debería tener la caja de detalle
		// Antes de calcular la posición absoluta de la caja de detalle la abrimos por si está cerrada,
		// ya que en ese caso daría como posición absoluta (0,0).
		var posAbsolutaContenidoDetalle = getPosicionAbsoluta($(cajaDetalleId)); 
		var detalleHeight = bottomViewport - posAbsolutaContenidoDetalle.top;

		// Si la altura calculada para el detalle es menor que el mínimo ponemos
		// como altura el mínimo. Esto es para evitar un detalle muy pequeño, si la imagen
		// es muy pequeña en altura
		if (detalleHeight < minHeight)
			detalleHeight = minHeight; 
		
		// Establecemos el alto máximo de la caja de detalle y un overflow alto, por si el
		// contenido es mayor que ese tamaño máximo.
	    if (Prototype.Browser.IE && (BrowserDetect.version == 6)) {
	    	$(cajaDetalleId).setStyle ({height: detalleHeight + 'px', overflow: 'auto'});
		} else {
			$(cajaDetalleId).setStyle ({maxHeight: detalleHeight + 'px', overflow: 'auto'});
		}
	}
}

var lastAlto = -1;
var lastAncho = -1;

/**
 Cambia el tamaño de la imagen al nuevo alto y ancho pasado.
*/
function changeSize (imagen, viewport, alto, ancho)
{
	// Obtenemos el ancho del viewport
	var anchoViewport = $(viewport).getWidth();
	
	// Calculamos el margen izquierdo
	var anchoLibre = anchoViewport - ancho;
	var margenIzq = anchoLibre / 2;
	
	// Control de que no se intente redimensionar para dejarlo igual que estaba
	// Lo que si hacemos es establecer el margen izquierdo para centrarlo en la pantalla
	if ((alto == lastAlto) && (ancho == lastAncho))
	{
		// Establecemos el nuevo alto y ancho en la imagen, y si el ancho de la imagen es menor que el
		// ancho del viewport, establecemos un margen izquierdo para centrarla en el viewport
		if (ancho < anchoViewport)
			imagen.setStyle ({marginLeft: margenIzq + 'px'});
		else imagen.setStyle ({marginLeft: '0'});
	
		return;
	}  
	
	// Obtenemos el zoom actual del visualizador y la posición actual para luego volver a ponerlas
	var zoom = getZoomVisualizador (imagen);
	var position = getPosicionVisualizador (imagen);

	// Eliminamos la imagen del visualizador antes de establecer los nuevos tamaños
	removeImagenVisualizador (imagen);	
	
	// Establecemos el nuevo alto y ancho en la imagen, y si el ancho de la imagen es menor que el
	// ancho del viewport, establecemos un margen izquierdo para centrarla en el viewport
	imagen.setStyle ({height: alto + 'px', width: ancho + 'px'});
	if (ancho < anchoViewport)
		imagen.setStyle ({marginLeft: margenIzq + 'px'});
	else imagen.setStyle ({marginLeft: '0'});
	
	// Si hay un zoom establecido mayor del 10%, añadimos la imagen con ese zoom y
	// en la posición que tenían anteriormente
	if (zoom >= 10)
	{
		addImagenVisualizador (imagen, position.x, position.y, zoom);
	}
	// Sino añadimos la imagen tal cual, sin zoom y en la posición inicial
	else addImagenVisualizador (imagen);

	// Indicamos que el ancho del viewport es del 100%
	$(viewport).setStyle ({width: '100%'});
	
	lastAlto = alto;
	lastAncho = ancho;
	actualizarCoordenadas();
}

var __comenzarZoomAncho = false;
var __zoomComienzo = null;  // Nivel de zoom por defecto (entre 0 y 100) 

function setComenzarZoomAncho (comenzarZoomAncho)
{
	__comenzarZoomAncho = comenzarZoomAncho;
}
function setZoomComienzo (zoomComienzo)
{
	__zoomComienzo = zoomComienzo;
}

var cajaDetalleId;

/**
 Inicializa el visualizador de imágenes con la imagen y el viewport pasados. Si se indica
 un id de detalle, contendrá una caja de detalle asociada al visualizador que tendrá el mismo
 tamaño.
*/
function inicializarVisualizador(imagenId, viewportId, detalleId)
{
	// Inicializamos el id de la caja de detalle si es que tiene
	cajaDetalleId = detalleId;

	addListener (window, "resize", function() {
		redimensionarVisualizador(imagenId, viewportId);
	});
    redimensionarVisualizador(imagenId, viewportId);
	addImagenVisualizador ($(imagenId));
    redimensionarVisualizador(imagenId, viewportId);
    
    var zoom = getPrefZoom();
    if (zoom != null) {
        setZoom (imagenId, zoom, 50, 0);
    } else if (__zoomComienzo) {
        setZoom (imagenId, __zoomComienzo, 50, 0);
    } else if (__comenzarZoomAncho) {
        zoomAnchoVisualizador (imagenId, viewportId);
    }
}

/**
 Aumenta el zoom de la imagen en el visualizador. 
*/
function zoomMasVisualizador (imagenId)
{
	// Obtenemos la imagen por su id
	var imagen = $(imagenId);
	
	// Permitimos que se pueda hacer zoom
	shiftzoom.set(imagen,'zoomin',true);
	
	// Obtenemos la posici?n actual y el zoom actual del visualizador
	var posActual = getPosicionVisualizador (imagen);
	var zoom = getZoomVisualizador (imagen);

	// Aumentamos un 10% el zoom cada vez, sin superar el 100%	
	zoom = (zoom + 10) < 100 ? (zoom + 10) : 100;
	
	// Establecemos el nuevo zoom en la posición actual
	shiftzoom.kenburns ($(imagenId), posActual.x, posActual.y, zoom, false, 1, 1);
	
	setPrefZoom (zoom);
}

/**
 Disminuye el zoom de la imagen en el visualizador.
*/
function zoomMenosVisualizador (imagenId)
{
	// Obtenemos la imagen por su id
	var imagen = $(imagenId);
	
	// Permitimos que se pueda quitar zoom
	shiftzoom.set($(imagenId),'zoomout',true);
	
	// Obtenemos la posición actual y el zoom actual del visualizador
	var posActual = getPosicionVisualizador (imagen);
	var zoom = getZoomVisualizador (imagen);
	
	// Reducimos un 10% el zoom cada vez, sin superar el 0%	
	zoom = (zoom - 10) > 0 ? (zoom - 10) : 0;

	// Establecemos el nuevo zoom en la posición actual
	shiftzoom.kenburns ($(imagenId), posActual.x, posActual.y, zoom, false, 1, 1);

	setPrefZoom (zoom);
}

/**
 Establece un zoom sobre la imagen de forma que se adapte al ancho
 de la imagen. 

 imagenId: Atributo id de la imagen.
*/
function zoomAnchoVisualizador (imagenId, viewportId)
{
	var imagen = $(imagenId);
	var viewport = $(viewportId);
	
	// Obtenemos las dimensiones originales de la imagen
	var alturaImg = getNaturalHeight (imagen);
	var anchuraImg = getNaturalWidth (imagen);
	
	// Obtenemos las dimensiones del viewport	
	var anchoViewport = $(viewport).getWidth();
	var altoViewport = $(viewport).getHeight();

	// Calculamos la proporción de la altura y anchura del vieport con respecto a la altura
	// y anchura originales
	var propAltura = altoViewport / alturaImg;
	var propAnchura = anchoViewport / anchuraImg;
	
	// Si la proporción de altura es mayor que la de anchura no se hace zoom
	if (propAltura >= propAnchura) {
		zoom = 0;
	} 
	else 
	{
		// Como anchura nueva cogemos la anchura del viewport
		var anchuraNueva = anchoViewport;
	
		// Obtenemos las dimensiones actuales de la imagen dentro del viewport, para obtener su ancho actual
		var dimensionesActuales = getDimensionesRelativas (imagen, viewport);
		var anchoActual = dimensionesActuales.anchura;

		// Para calcular el zoom proporcionalmente al nuevo ancho, habrá que restar el ancho actual de la imagen
		// tanto a la nueva anchura, como a la anchura total de la imagen, es decir, el 100% del zoom será el
		// ancho total de la imagen menos el ancho actual.
		zoom = (anchuraNueva - anchoActual) * 100 / (anchuraImg - anchoActual);
	}
	
	// Establecemos el nuevo zoom	
	setZoom (imagenId, zoom, 50, 0);
}

/**
 Establece un zoom sobre la imagen, cuyo id se pasa como parámetro.<b> 

 imagenId: Atributo id de la imagen.
 zoom: valor de zoom a establecer. (0-100%).
*/
function setZoom (imagenId, zoom, nuevox, nuevoy)
{
	// Obtenemos la imagen por su id
	var imagen = $(imagenId);
	
	// Obtenemos la posición actual y el zoom actual del visualizador
	var posActual = getPosicionVisualizador (imagen);
	
	if (zoom < 0)
		zoom = 0;
	else if (zoom > 100)
		zoom = 100;
	
	// La posicion puede mantenerse o ponerse la nueva	
	var x = ((nuevox != null) && (nuevox >= 0)? nuevox : posActual.x);
	var y = ((nuevoy != null) && (nuevoy >= 0)? nuevoy : posActual.y);
	
	// Establecemos el nuevo zoom en la posición actual
	shiftzoom.kenburns (imagen, x, y, zoom, false, 1, 1);
	
	setPrefZoom (zoom);
}

function moverImagenVisualizador (imagenId, nuevox, nuevoy)
{
	var zoom = getZoomVisualizador ($(imagenId));
	setZoom (imagenId, zoom, nuevox, nuevoy);
}

/**
 Añade un listener para el elemento y el evento.
*/
function addListener(element, event, listener, bubble) {
  if(element.addEventListener) {
    if(typeof(bubble) == "undefined") bubble = false;
    element.addEventListener(event, listener, bubble);
  } else if(this.attachEvent) {
    element.attachEvent("on" + event, listener);
  }
}


var __marginVisualizador = null;

function alAbrirCerrarDetalle (inicializando)
{
	if (!inicializando)  togglePrefDetalleAbierto();
	
	// Se obtiene el element .nav_registros
	var nodoMarco = $$('.nav_registros')[0];
	
	// Se cambia su margin-left:
	// - si es distinto de cero, se guarda y se pone cero
	// - si es cero, se pone otra vez el guardado
	var margLeft = nodoMarco.getStyle ('margin-left');
	if ((margLeft != 0) && (margLeft != '0') && (margLeft != '0pt') && (margLeft != '0px')) {
		__marginVisualizador = nodoMarco.getStyle ('margin');
		nodoMarco.setStyle ({margin: '0'});
	} else {
		nodoMarco.setStyle ({margin: __marginVisualizador});
	}
	redimensionarVisualizador ('imagezoom', 'visualizador_pantalla');
	actualizarCoordenadas();
}


var __inicializando = false;
var __ventanaCargada = false;

function alAbrirCerrarPantallaCompleta()
{
	if (!__inicializando)  togglePrefPantallaCompleta();
	redimensionarVisualizador ('imagezoom', 'visualizador_pantalla');
	actualizarCoordenadas();
}


/**** Funciones de respuesta a la carga de la imagen (ok, error) ****/

function okCargaImagen()
{
	// No se puede inicializar el visualizador hasta que no se haya cargada la ventana
	if (!__ventanaCargada || __ventanaCargada == false)
	{
		window.setTimeout("okCargaImagen();", 10);
		return;
	}
	$('encurso').hide();
	inicializarVisualizador('imagezoom', 'visualizador_pantalla', 'contenido_detalle');
}

function errorCargaImagen()
{
	$('encurso').hide();
	$('imagezoom').show();
	$('imagezoom').setStyle ({visibility: 'visible'});
}

var __oldY = -10;
var __oldZ = -10;
var __oldAlturaImgZoom = -10;

var scrollVertical = null;

var __reboteScroll = false;

var zonas = new Array();
var papers = new Array();
var recuadros = new Array();
var config_rotacion=0;


/**
 Obtiene las dimensiones y coordenadas absolutas del elemento
*/
getDimensions = function(oElement) {
	var x, y, w, h;
	x = y = w = h = 0;
	if (document.getBoxObjectFor) { // Mozilla
		var oBox = document.getBoxObjectFor(oElement);
		x = oBox.x-1;
		w = oBox.width;
		y = oBox.y-1;
		h = oBox.height;
	}
	else if (oElement.getBoundingClientRect) { // IE
		var oRect = oElement.getBoundingClientRect();
		x = oRect.left-2;
		w = oElement.clientWidth;
		y = oRect.top-2;
		h = oElement.clientHeight;
	}
	return {x: x, y: y, w: w, h: h};
}


function pintarAreasOcr() {

	var img = $('imagezoom');
	var viewport = $('visualizador_pantalla');
	
	if ((img==null)||(viewport==null)) return null;
	
	//Cogemos el maximo tamaño de la imagen ya que pintaremos los recuadros en funcion de ello
	var img_height_total = img.maxheight;
	var img_width_total = img.maxwidth;
	
	if ((img_height_total==null)||(img_width_total==null)) {
		img_height_total=400;
		img_width_total=400;
	};
	
	if (zonas.length>0){
		var i=0;
		for (i=0; i<zonas.length; i++) {
		
			var padding = 3;
		
			//Cogemos los datos de los recuadros
			var x_rotacion = zonas[i][0];
			var y_rotacion = zonas[i][1];
			var altura_rotacion = zonas[i][2];
			var anchura_rotacion = zonas[i][3];
			
			//Ajustamos las coordenadas al tamaño real de la imagen
			var ajuste = img_height_total / altoRelativoZonas;
			if ((config_rotacion == 90) || (config_rotacion == 270))
				ajuste = img_width_total / altoRelativoZonas;
			
			x_rotacion = x_rotacion * ajuste;
			y_rotacion = y_rotacion * ajuste;
			altura_rotacion = altura_rotacion * ajuste;
			anchura_rotacion = anchura_rotacion  * ajuste;
			
			var zona = new Array(4);
			//Caso de que no haya rotacion
			zona[0]=x_rotacion;
			zona[1]=y_rotacion;
			zona[2]=altura_rotacion;
			zona[3]=anchura_rotacion;
			
			//Ajustamos los recuadros segun el angulo de la imagen. 
			//Pintaremos los recuadros en un origen diferente y con alutra y anchuras diferentes
			switch(config_rotacion)
			{
				case 90:
					zona[0] = img_width_total - y_rotacion - altura_rotacion;
					zona[1] = x_rotacion;
					zona[2] = anchura_rotacion;
					zona[3] = altura_rotacion;
					break;
				case 180:
					zona[0] = img_width_total - x_rotacion - anchura_rotacion;
					zona[1] = img_height_total - y_rotacion - altura_rotacion;
					break;
				case 270:
					zona[0] = y_rotacion;
					zona[1] = img_height_total - x_rotacion - anchura_rotacion;
					zona[2] = anchura_rotacion;
					zona[3] = altura_rotacion;
					break;
			}
			
			//Calculamos las posiciones x e y relativos al tamaño actual de la imagen
			var i_x = (img.height * ((zona[0])/img_height_total));
			var i_y = (img.width * ((zona[1])/img_width_total));
			
			//Ajustamos donde tenemos que pintar segun las posiciones relativas del viewport y la imagen
			var coor_x = (i_x+getDimensions(img).x) - (padding/2);
			var coor_y = (i_y+getDimensions(img).y) - (padding/2);
			
			var ajuste_altura = img.height / img_height_total;
			var ajuste_anchura = img.width / img_width_total;
			var i_anchura = zona[3]*ajuste_anchura + padding;
			var i_altura = zona[2]*ajuste_altura + padding;
			
			//paper = Raphael(viewport, viewport.height, viewport.width);
			
			var i_anchura_nueva=i_anchura;
			var i_altura_nueva=i_altura;
			
			
			//Se ajusta el recuadro en caso de que sobrepase alguno de los limites del viewport
			var viewport_x = getDimensions(img).x - img.offsetLeft + 1;
			var viewport_y = getDimensions(img).y - img.offsetTop + 1;

			if ((coor_x>(viewport_x +viewport.getDimensions().width)-i_anchura)&&(coor_x<(viewport_x+viewport.getDimensions().width))) {
				if (recuadros[i]!=null) recuadros[i].remove();
				var i_anchura_nueva = ((viewport_x+viewport.getDimensions().width))-coor_x;
			}
			
			if ((coor_y>(viewport_y +viewport.getDimensions().height)-i_altura)&&(coor_y<(viewport_y +viewport.getDimensions().height))) {
				if (recuadros[i]!=null) recuadros[i].remove();
				var i_altura_nueva = ((viewport_y +viewport.getDimensions().height))-coor_y;
			}
		
			if ((coor_x<(viewport_x))&&((coor_x+i_anchura)>(viewport_x))) {
				if (recuadros[i]!=null) recuadros[i].remove();
				i_anchura_nueva = i_anchura-((viewport_x)-coor_x);
				coor_x = viewport_x;
			}
			
			if ((coor_y<(viewport_y))&&((coor_y+i_altura)>(viewport_y))) {
				if (recuadros[i]!=null) recuadros[i].remove();
				i_altura_nueva = i_altura-((getDimensions(viewport).y)-coor_y);
				coor_y = viewport_y;
			}
			
			var flag_pintar=1; //flag para que no cree el paper en caso de que no tenga que pintarse
			if ((coor_x > (viewport_x+viewport.getDimensions().width))||((coor_x+i_anchura) < viewport_x)) {
				flag_pintar=0;
			}
			if ((coor_y > (viewport_y +viewport.getDimensions().height))||((coor_y+i_altura) < viewport_y )) {
				flag_pintar=0;
			}
		
			if (papers[i]!=null) {
				papers[i].remove();
				papers[i]=null;
			}
			if (recuadros[i]!=null) recuadros[i].remove();
			
			//Sumamos el desplazamiento del scroll a las coordenadas
			if ((Prototype.Browser.IE) &&(BrowserDetect.version == 6)) {
				coor_x+=document.body.scrollLeft;
				coor_y+=document.body.scrollTop;
			} else {
				coor_x+=document.documentElement.scrollLeft;
				coor_y+=document.documentElement.scrollTop;
			}
			
			if (flag_pintar==1) {
				//Creamos el espacio donde vamos a pintar segun las coordenadas y tamaños calculados
				papers[i] = Raphael(coor_x,coor_y,i_anchura_nueva+1,i_altura_nueva+1); 	
				//papers[i].safari();
	
				//Pintamos los recuadros en los espacios para pintar segun las coordenadas y tamaños calculados
				recuadros[i] = papers[i].rect(0,0,i_anchura_nueva,i_altura_nueva);
				recuadros[i].attr({fill: "yellow", stroke: "red", "fill-opacity": 0.4});
			}
		}
	}
}

function actualizarCoordenadas()
{
	if (redimensionando==true) {
		window.setTimeout("actualizarCoordenadas();",10);
	}
	
	var img = $('imagezoom');
	var viewport = $('visualizador_pantalla');
	if ((img==null)||(viewport==null)) return null;
	var coords = shiftzoom.get (img, "currentxyz");
	var y = coords.y;
	var z = coords.z;
	var alturaViewport = viewport.getHeight();
	var alturaImgZoom = img.getHeight();
	var alturaScroll = parseFloat($('scroll_slider').getStyle("height"));
	
	
	var cambioZoom = ((z != __oldZ) || (alturaImgZoom != __oldAlturaImgZoom));
	if ((y != __oldY) || cambioZoom || alturaViewport!=alturaScroll) {
		__oldY = y;
		__oldZ = z;
		__oldAlturaImgZoom = alturaImgZoom;
		
		if (cambioZoom || alturaViewport!=alturaScroll) {
			var dif = alturaImgZoom - alturaViewport;
			var valorMin = (100 * alturaViewport) / (2 * alturaImgZoom);
			var valorMax = 100 - valorMin;

			// Se modifican estilos de la barra de scroll
		    var scroll_slider = $('scroll_slider');
			scroll_slider.setStyle ({'height': alturaViewport + 'px'});
			scroll_slider.setStyle ({'top': '0px'});

			// Se modifican estilos del boton del scroll
		    var handle_slider = scroll_slider.down('.handle');
			var alturaHandle = Math.round ((alturaViewport * alturaViewport) / alturaImgZoom);
		    alturaHandle = Math.max (alturaHandle, 11);
		    if (!(alturaHandle > 0))  alturaHandle = 0;
		    handle_slider.setStyle ({'height': alturaHandle + 'px'});
		    
			// Se crea una nueva barra de scroll JS con el nuevo rango
			if (scrollVertical)  scrollVertical.dispose();
			if (z > 0) {
		    	handle_slider.setStyle ({'display': 'block'});
			    scrollVertical = new Control.Slider (handle_slider, scroll_slider, {
			      range: $R (valorMin, valorMax),
			      sliderValue: y,
			      axis: 'vertical',
			      onSlide: function(value) {
			      	if (!__reboteScroll)  moverImagenVisualizador ('imagezoom', null, value);
			      },
			      onChange: function(value) { 
			      	if (!__reboteScroll)  moverImagenVisualizador ('imagezoom', null, value);
			      }
			    });
		    	handle_slider.setStyle ({'cursor': 'default'});
			} else {
		    	handle_slider.setStyle ({'display': 'none'});
			}

		} else {
			if (scrollVertical) {
				__reboteScroll = true;
				scrollVertical.setValue (y);
				__reboteScroll = false;
			}
		}
	}
	pintarAreasOcr();
}


/***** Funciones de acceso a preferencias del cliente *****/

var __valorPreferencias = null;
var __nombreCookie = "digibis_catalogo_imagenes.preferencias";
var __duracionCookie = 3600 * 24 * 30;   // 30 dias

var __presentacionMiniaturas = false;

var __detalleAbiertoMinisDef = "S";
var __detalleAbiertoPaginaDef = "S";


function hayPreferencias()
{
	return (__valorPreferencias != null) || (Cookie.get (__nombreCookie) != null);
}

function getPreferencias()
{
	if (__valorPreferencias == null) {
		__valorPreferencias = Cookie.get (__nombreCookie);
	}
	var valPref = __valorPreferencias;
	
	var valPrefDefault = "N" + __detalleAbiertoMinisDef + __detalleAbiertoPaginaDef;
	if (valPref == null)  valPref = valPrefDefault;
	if (valPref.length < valPrefDefault.length) {
		valPref = valPref + valPrefDefault.substring (valPref.length);
	}
	
	return valPref;
}

function getPreferenciaValor (i)
{
	var valPref = getPreferencias();
	var trozos = valPref.split ('#');
	return trozos[i];
}

function setPreferenciaValor (i, valor)
{
	var valPref = getPreferencias();
	var trozos = valPref.split ('#');
	if (trozos.length < i + 1)  trozos.length = i + 1;
    trozos[i] = valor;
    var nuevoVal = trozos.join ('#');
    
    if (__valorPreferencias != nuevoVal) {
    	__valorPreferencias = nuevoVal;
    	Cookie.set (__nombreCookie, nuevoVal, __duracionCookie);
    }
}

function getFlagPreferencia (i)
{
	var valPref = getPreferenciaValor(0);
	return valPref.substring (i,i+1);
}

function setFlagPreferencia (i, valor)
{
	var valPref = getPreferenciaValor(0);
	var nuevoVal = "";
	if (i > 0) nuevoVal += valPref.substring (0, i);
	nuevoVal += valor;
	nuevoVal += valPref.substring (i+1);
	setPreferenciaValor (0, nuevoVal);
}
function getPrefBoolean (i)
{
	return (getFlagPreferencia(i) == "S");
}
function togglePrefBoolean (i)
{
	var oldVal = getPrefBoolean (i);
	var nuevoVal = (oldVal? "N" : "S");
	setFlagPreferencia (i, nuevoVal);
}
function getPrefPantallaCompleta()
{
	return getPrefBoolean(0);
}
function togglePrefPantallaCompleta()
{
	togglePrefBoolean (0);
}
function getPrefDetalleAbierto()
{
	return getPrefBoolean (__presentacionMiniaturas? 1 : 2);
}
function togglePrefDetalleAbierto()
{
	togglePrefBoolean (__presentacionMiniaturas? 1 : 2);
}
function setPrefDetalleAbiertoPagina(valor)
{
	if (getPrefBoolean(2) != valor) togglePrefBoolean (2);
}
function setPreferenciasDef (detalleAbiertoMinis, detalleAbiertoPagina)
{
	if (!hayPreferencias()) {
		if (!detalleAbiertoMinis) __detalleAbiertoMinisDef = "N";
		if (!detalleAbiertoPagina) __detalleAbiertoPaginaDef = "N";
	}
}

function getPrefZoom()
{
    var sZoom = getPreferenciaValor (1);
    if ((sZoom == null) || (sZoom == ''))
        return null;
    else
        return parseFloat (getPreferenciaValor (1));
}
function setPrefZoom (valor)
{
    return setPreferenciaValor (1, valor);
}