<!--
	// Abre una ventana de confirmacion al pulsar un enlace
	// idenlace: id del enlace que se quiera confirmar
	// msg: mensaje de confirmacion
    function confirmarEnlace (idenlace, msg)
    {
        addFuncionOnLoad (function() {
            var link = getObj(idenlace);
            var uri = link.href;
            link.onclick = function() {
                if (confirm (msg)) {
                    link.href = uri;
                }
            }
            link.href = "#";
        });
    }

	// Auxiliar para la siguiente
	var funciones_onload = (funciones_onload? funciones_onload : new Array());
	function runMultipleOnLoad()
	{
		for(var i=0; i<funciones_onload.length; i++)
			funciones_onload[i]();
			
		 funciones_onload=void 0;
	}
	
	// *** Añade una funcion para que se ejecute al cargar una pagina
	function addFuncionOnLoad (funcion)
	{
		var old_onload = window.onload;
		if (old_onload == null) {
			window.onload = funcion;
		} else if (old_onload == runMultipleOnLoad) {
			funciones_onload.push (funcion);
		} else {
			window.onload = runMultipleOnLoad;
			funciones_onload.push (old_onload);
			funciones_onload.push (funcion);
		}
	}
	
	// Abre una nueva ventana para mostrar una imagen, sin modificar la ventana principal
	function PopUp(url) {
	  //posLeft = (screen.availWidth / 2) - (600 / 2);
	  //posTop = (screen.availHeight / 2) - (400 / 2);
	  //window.open (url, "Imagen", "width=600,height=400,left="+posLeft+",top="+posTop+",toolbar=1,location=0,resizable=1,scrollbars=1");
	  window.open (url);
	}

	function frameOrPopup (frame, url, urlPopup, width, height) {
		if (!urlPopup)  urlPopup = url;
		if (parent.frames && parent.frames[frame]) {
			parent.frames[frame].location = url;
		} else {
			var config = "location=1,menubar=1,resizable=1,scrollbars=1,status=1,titlebar=1,toolbar=1";
			if (width) {
			    config = config + ",width=" + width;
			    var sx = (screen.availWidth / 2) - (width / 2);
			    if (screen.availWidth)  config = config + ",left=" + sx + ",screenX=" + sx;
			}
			if (height) {
			    config = config + ",height=" + height;
			    var sy = 10;
//			    var sy = (screen.availHeight / 2) - (height / 2);
			    if (screen.availHeight)  config = config + ",top=" + sy + ",screenY=" + sy;
			}
			window.open (urlPopup, "", config);
		}
	}

	
/**
 *
 *  URL encode / decode
 *  http://www.webtoolkit.info/
 *
 */
var Url = {

    // public method for url encoding
    encode : function (string) {
        return escape(this._utf8_encode(string));
    },

    // public method for url decoding
    decode : function (string) {
        return this._utf8_decode(unescape(string));
    },

    // private method for UTF-8 encoding
    _utf8_encode : function (string) {
        string = string.replace(/\r\n/g,"\n");
        var utftext = "";

        for (var n = 0; n < string.length; n++) {

            var c = string.charCodeAt(n);

            if (c < 128) {
                utftext += String.fromCharCode(c);
            }
            else if((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            }
            else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }

        }

        return utftext;
    },

    // private method for UTF-8 decoding
    _utf8_decode : function (utftext) {
        var string = "";
        var i = 0;
        var c = c1 = c2 = 0;

        while ( i < utftext.length ) {

            c = utftext.charCodeAt(i);

            if (c < 128) {
                string += String.fromCharCode(c);
                i++;
            }
            else if((c > 191) && (c < 224)) {
                c2 = utftext.charCodeAt(i+1);
                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                i += 2;
            }
            else {
                c2 = utftext.charCodeAt(i+1);
                c3 = utftext.charCodeAt(i+2);
                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                i += 3;
            }

        }

        return string;
    }
}

	/*
	  Crea un botón para que un elemento html se pueda visualizar a pantalla completa.
	  
	  idElemento Atributo id del elemento html.
	*/ 
	function newBotonPantallaCompleta (idElemento)
	{
		// Creamos un objeto que almacene la configuración de pantalla completa de un elemento
		var botonPantallaCompleta = new Object();

		// Inicializamos el objeto		
		botonPantallaCompleta.idElemento = idElemento;
		
		// Por defecto el elemento estará en estado normal. Si este atributo vale 'completo' se
		// deberá poner a tamaño completo
		botonPantallaCompleta.estado = 'normal';
		
		// Flag que indica si al cambiar a pantalla completa hay que establecer un marco alrededor
		// del contenido
		botonPantallaCompleta.usarMarco = true;
		
		// Estilo del marco si botonPantallaCompleta.usarMarco es true y botonPantallaCompleta.estado = 'completo' 
		botonPantallaCompleta.estiloMarco = {'borderStyle': 'outset', 'borderWidth': '0.2em', 'padding': '0.5em'};
		
		// Atributo que guarda los estilos originales utilizados para enmarcar el elemento, para al volver a pantalla normal
		// ponerlos de nuevo 
		botonPantallaCompleta.estiloOriginalMarco = new Hash();
		
		// Atributo que almacena los estilos originales del elemento idElemento, y de los elementos que afecten al visualizador
		// en su modo pantalla completa, para que cuando se reestablezca el elemento a pantalla normal, se vuelvan a poner los 
		// estilos originales		
		botonPantallaCompleta.estilosOriginales = new Hash();

		// Devolvemos el objeto
		return botonPantallaCompleta;
	}

	/*
	  Establece los márgenes del elemento a los valores pasados. Se modifica el estilo
	  establecido para el elemento.
	  
	  elemento Atributo id del elemento.
	  left     Cadena de caracteres con el valor para el margen izquierdo.
	  rigth    Cadena de carccateres con el valor para el margen derecho.
	  top      Cadena de carccateres con el valor para el margen superior.
	  bottom   Cadena de carccateres con el valor para el margen inferior.
	*/	
	function setMargenes (elemento, margenes)
	{
		$(elemento).setStyle({left: margenes.get('left')}); 
		$(elemento).setStyle({right: margenes.get('right')}); 
		$(elemento).setStyle({top: margenes.get('top')}); 
		$(elemento).setStyle({bottom: margenes.get('bottom')});
		$(elemento).setStyle({marginLeft: margenes.get('marginLeft')}); 
		$(elemento).setStyle({marginRight: margenes.get('marginRight')}); 
		$(elemento).setStyle({marginTop: margenes.get('marginTop')}); 
		$(elemento).setStyle({marginBottom: margenes.get('marginBottom')}); 
	}

	/*
      Obtiene los márgenes establecidos en el estilo de un elemento.
      
      elemento Atributo id del elemento
      Devuelve un objeto Hash con los márgenes ('left', 'right', 'top', 'bottom').	
	*/
	function getMargenes (elemento)
	{
		var margenes = new Hash();
		margenes.set ('left', $(elemento).getStyle('left'));
		margenes.set ('right', $(elemento).getStyle('right'));
		margenes.set ('top', $(elemento).getStyle('top'));
		margenes.set ('bottom', $(elemento).getStyle('bottom'));
		margenes.set ('marginLeft', $(elemento).getStyle('marginLeft'));
		margenes.set ('marginRight', $(elemento).getStyle('marginRight'));
		margenes.set ('marginTop', $(elemento).getStyle('marginTop'));
		margenes.set ('marginBottom', $(elemento).getStyle('marginBottom'));
		return margenes;
	}

	/**
	 Pone un marco o se lo quita al elemento que se va a colocar en pantalla completa.
	 Sólo se hace si botonPantallaCompleta.usarMarco es true.
	*/ 
	function __enmarcarElemento (botonPantallaCompleta, enmarcar)
	{
		// Si la configuración dice que no se establece marco no se hace nada
		if (!botonPantallaCompleta.usarMarco)
			return;
			
		var idElemento = botonPantallaCompleta.idElemento;
		if ($(idElemento) && enmarcar)
		{
			botonPantallaCompleta.estiloOriginalMarco.set ('borderStyle', $(idElemento).getStyle('borderStyle'));
			botonPantallaCompleta.estiloOriginalMarco.set ('borderWidth', $(idElemento).getStyle('borderWidth'));
			botonPantallaCompleta.estiloOriginalMarco.set ('padding', $(idElemento).getStyle('padding'));
			
			// Establecemos el estilo para que muestre un marco alrededor del elemento contenido
			$(idElemento).setStyle(botonPantallaCompleta.estiloMarco);
		}
		else if ($(idElemento) && !enmarcar)
		{
			// Volvemos a poner el estilo original del elemento
			$(idElemento).setStyle({'borderStyle': botonPantallaCompleta.estiloOriginalMarco.get ('borderStyle'), 
			                         'borderWidth': botonPantallaCompleta.estiloOriginalMarco.get ('borderWidth'),
			                         'padding': botonPantallaCompleta.estiloOriginalMarco.get ('padding')});
		}
	}

	/**
	 Quita los estilos del elemento body que puedan influir en el correcto funcionamiento de pasar
	 a pantalla completa un elemento.
	*/
	function __quitarEstilosBody (botonPantallaCompleta)
	{
		// Obtenemos el elemento body
		var body = document.getElementsByTagName ("body")[0];
		
		// Guardamos el estilo de body
		var estilosOriginales = getMargenes(body);
		estilosOriginales.set ('textAlign', $(body).getStyle("textAlign"));
		botonPantallaCompleta.estilosOriginales.set ('body', estilosOriginales);
			
		// Establecemos márgenes a 0 y posición a 0
		var margenes = new Hash();
		margenes.set ('left', '0em');
		margenes.set ('right', '0em');
		margenes.set ('top', '0em');
		margenes.set ('bottom', '0em');
		margenes.set ('marginLeft', '0em');
		margenes.set ('marginRight', '0em');
		margenes.set ('marginTop', '0em');
		margenes.set ('marginBottom', '0em');
		setMargenes (body, margenes);
		
		// Establecemos el estilo text-align a la izquierda
		$(body).setStyle ({textAlign: "left"});	
	}

	/**
	 Recupera los estilos del elemento body que se quitan con la función __quitarEstilosBody.
	*/
	function __recuperarEstilosBody (botonPantallaCompleta)
	{
		// Obtenemos el elemento body
		var body = document.getElementsByTagName ("body")[0];
		
		// Guardamos el estilo de body
		var estilosOriginales = botonPantallaCompleta.estilosOriginales.get('body');
			
		// Establecemos márgenes y posición originales
		var margenes = new Hash();
		margenes.set ('left', estilosOriginales.get('left'));
		margenes.set ('right', estilosOriginales.get('right'));
		margenes.set ('top', estilosOriginales.get('top'));
		margenes.set ('bottom', estilosOriginales.get('bottom'));
		margenes.set ('marginLeft', estilosOriginales.get('marginLeft'));
		margenes.set ('marginRight', estilosOriginales.get('marginRight'));
		margenes.set ('marginTop', estilosOriginales.get('marginTop'));
		margenes.set ('marginBottom', estilosOriginales.get('marginBottom'));
		setMargenes (body, margenes);
		
		// Establecemos el estilo text-align a la izquierda
		$(body).setStyle ({textAlign: estilosOriginales.get('textAlign')});	
	}

	/*
		Pone la ventana en pantalla completa sobre el elemento del id dado,
		sin que sea necesario que exista un boton para ello.
	*/
	function pantallaCompleta (idElemento)
	{
		togglePantallaCompleta (null, idElemento);
	}
	
	
	var __enPantallaCompleta = false;
	
	/*
		Devuelve true si estamos en pantalla completa
	*/
	function enPantallaCompleta()
	{
		return __enPantallaCompleta;
	}
	
	/*
	  Cambia el estado del elemento establecido en botonPantallaCompleta, al modo pantalla completa o al 
	  modo pantalla normal dependiendo de su estado actual.
	  
	  botonPantallaCompleta Objeto creado con el método new BotonPantallaCompleta.
	*/		 
	function cambiarEstado (botonPantallaCompleta)
	{
		togglePantallaCompleta (botonPantallaCompleta, null);
	}

	/* Funcion interna */
	function togglePantallaCompleta (botonPantallaCompleta, idElemento)
	{
		// idElemento extraido del boton
		if (idElemento == null) {
			idElemento = botonPantallaCompleta.idElemento;
			
			// Si no existe el elemento contenido no se hace nada
			if (!$(idElemento)) {
				alert ('El modo a pantalla completa no se ha configurado correctamente. Consulte con el administrador de la web.');
				return;
			}
			
		// Se crea boton "auxiliar" si no existe o no es necesario
		} else if (botonPantallaCompleta == null) {
			botonPantallaCompleta = newBotonPantallaCompleta (idElemento);
			botonPantallaCompleta.usarMarco = false;	// En ese caso, por defecto no se pone borde (se considera que la pantalla se abre directamente en pantalla completa por algun motivo)
		}
		
		// Obtenemos el elemento body
		var body = document.getElementsByTagName ("body")[0];
		
		// Obtenemos el elemento sobre el que vamos a cambiar el estado
		var elemento = $(idElemento);
		
		// Hay que cambiar a pantalla completa	
		if (botonPantallaCompleta.estado == 'normal')
		{
			// Obtenemos todos los hijos de body
			var hijos = $(body).childElements();
		
			// Guardamos los hijos de body 
			botonPantallaCompleta.hijosBody = hijos;
			
			// Quitamos los estilos originales del body
			__quitarEstilosBody (botonPantallaCompleta);
			
			// Colocamos el elemento a maximizar como elemento de body para que sea el único visible
			botonPantallaCompleta.elementoPrevio = $(elemento).previous(0);
			if (!$(botonPantallaCompleta.elementoPrevio) || $(botonPantallaCompleta.elementoPrevio) == $(elemento))
			{
				botonPantallaCompleta.elementoPrevio = null;
				botonPantallaCompleta.elementoPadre = $(elemento).ancestors()[0];
			}
			$(elemento).remove();
			$(body).insert({top: elemento});
			
			// Guardamos los márgenes originales del elemento
			botonPantallaCompleta.estilosOriginales.set (elemento, getMargenes(elemento));
			
			// Establecemos los márgenes del elemento a los márgenes mínimos
			var margenes = new Hash();
			margenes.set ('left', '0em');
			margenes.set ('right', '0em');
			margenes.set ('top', '0em');
			margenes.set ('bottom', '0em');
			margenes.set ('marginLeft', '0.5em');
			margenes.set ('marginRight', '0.5em');
			margenes.set ('marginTop', '0.5em');
			margenes.set ('marginBottom', '0.5em');
			setMargenes (elemento, margenes);

			// Llamamos a enmarcar elemento si es que está activada al opción de enmarcar
			__enmarcarElemento (botonPantallaCompleta, true);
			
			// Recorremos todos los hijos de body y los ocultamos
			for (var i = 0; i < hijos.length; i++)
			{
				var id = hijos[i];
				if ($(id))
				{
					// Ocultamos el elemento
					$(id).hide();
				}
			} // Fin del for
			
			// Cambiamos el botón de pantalla completa a pantalla normal
			if ($('icono_pantalla_completa') != null) {
				var imgHtml = '<img id="icono_pantalla_completa" src="' + root_i18n + '/img/botones/pantalla_normal.gif"';
				imgHtml += ' alt="' + i18n_boton_pantalla_normal + '"';
				imgHtml += ' title="' + i18n_boton_pantalla_normal + '"';
				imgHtml += ' onmousedown="';
				imgHtml += "javascript: this.src='" + root_i18n + "/img/botones/pantalla_normal_pulsado.gif';";
				imgHtml += '" onmouseup="';
				imgHtml += "javascript: this.src='" + root_i18n + "/img/botones/pantalla_normal.gif';";
				imgHtml += '" />';
				$('icono_pantalla_completa').replace (imgHtml);
			}
			
			// Cambiamos el estado del boton a pantalla completa
			botonPantallaCompleta.estado = 'completo';
			
			__enPantallaCompleta = true;
		}			
		// Hay que pasar al modo pantalla normal
		else
		{
			// Quitamos el elemento que hemos maximizado del elemento body y lo colocamos en su posición natural
			var elemento = body.firstDescendant();
			if (botonPantallaCompleta.elementoPrevio != null)
				$(botonPantallaCompleta.elementoPrevio).insert({after: elemento});
			else $(botonPantallaCompleta.elementoPadre).insert({top: elemento});
			
			// Recuperamos los estilos originales del body
			__recuperarEstilosBody (botonPantallaCompleta);
			
			// Llamamos a desenmarcar elemento si es que está activada al opción de enmarcar
			__enmarcarElemento (botonPantallaCompleta, false);
			
			// Volvemos a poner los márgenes originales del elemento
			setMargenes (elemento, botonPantallaCompleta.estilosOriginales.get(elemento));
			
			// Obtenemos los hijos originales del elemento body
			var hijos = botonPantallaCompleta.hijosBody;
			
			// Recorremos todos los hijos de body y los mostramos
			for (var i = 0; i < hijos.length; i++)
			{
				var id = hijos[i];
				if ($(id))
				{
					// Mostramos el elemento
					$(id).show();
				}
			} // Fin del for
			
			// Cambiamos el botón de pantalla normal a pantalla completa
			if ($('icono_pantalla_completa') != null) {
				var imgHtml = '<img id="icono_pantalla_completa" src="' + root_i18n + '/img/botones/pantalla_completa.gif"';
				imgHtml += ' alt="' + i18n_boton_pantalla_completa + '"'; 
				imgHtml += ' title="' + i18n_boton_pantalla_completa + '"';
				imgHtml += ' onmousedown="';
				imgHtml += "javascript: this.src='" + root_i18n + "/img/botones/pantalla_completa_pulsado.gif';";
				imgHtml += '" onmouseup="';
				imgHtml += "javascript: this.src='" + root_i18n + "/img/botones/pantalla_completa.gif';";
				imgHtml += '" />';
				$('icono_pantalla_completa').replace (imgHtml);
			}
			
			// Cambiamos el estado del boton a pantalla normal
			botonPantallaCompleta.estado = 'normal';
			
			__enPantallaCompleta = false;
		}
		
	} // Fin de cambiarEstado


	/*
		Devuelve true si estamos dentro de un frame y el contenedor es del mismo
		dominio (host) que el frame.
	*/
	function enFrameInterno()
	{
		try {
			var locationActual = location;
			var locationMadre = top.location;
			return ((locationMadre != locationActual) && (locationMadre.host == locationActual.host));
		} catch (e) {
			return false;
		}
	}


	// Deteccion de navegador
	// (BrowserDetect.browser + BrowserDetect.version + BrowserDetect.OS)
	var BrowserDetect = {
		init: function () {
			this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
			this.version = this.searchVersion(navigator.userAgent)
				|| this.searchVersion(navigator.appVersion)
				|| "an unknown version";
			this.OS = this.searchString(this.dataOS) || "an unknown OS";
		},
		searchString: function (data) {
			for (var i=0;i<data.length;i++)	{
				var dataString = data[i].string;
				var dataProp = data[i].prop;
				this.versionSearchString = data[i].versionSearch || data[i].identity;
				if (dataString) {
					if (dataString.indexOf(data[i].subString) != -1)
						return data[i].identity;
				}
				else if (dataProp)
					return data[i].identity;
			}
		},
		searchVersion: function (dataString) {
			var index = dataString.indexOf(this.versionSearchString);
			if (index == -1) return;
			return parseFloat(dataString.substring(index+this.versionSearchString.length+1));
		},
		dataBrowser: [
			{
				string: navigator.userAgent,
				subString: "Chrome",
				identity: "Chrome"
			},
			{ 	string: navigator.userAgent,
				subString: "OmniWeb",
				versionSearch: "OmniWeb/",
				identity: "OmniWeb"
			},
			{
				string: navigator.vendor,
				subString: "Apple",
				identity: "Safari",
				versionSearch: "Version"
			},
			{
				prop: window.opera,
				identity: "Opera"
			},
			{
				string: navigator.vendor,
				subString: "iCab",
				identity: "iCab"
			},
			{
				string: navigator.vendor,
				subString: "KDE",
				identity: "Konqueror"
			},
			{
				string: navigator.userAgent,
				subString: "Firefox",
				identity: "Firefox"
			},
			{
				string: navigator.vendor,
				subString: "Camino",
				identity: "Camino"
			},
			{		// for newer Netscapes (6+)
				string: navigator.userAgent,
				subString: "Netscape",
				identity: "Netscape"
			},
			{
				string: navigator.userAgent,
				subString: "MSIE",
				identity: "Explorer",
				versionSearch: "MSIE"
			},
			{
				string: navigator.userAgent,
				subString: "Gecko",
				identity: "Mozilla",
				versionSearch: "rv"
			},
			{ 		// for older Netscapes (4-)
				string: navigator.userAgent,
				subString: "Mozilla",
				identity: "Netscape",
				versionSearch: "Mozilla"
			}
		],
		dataOS : [
			{
				string: navigator.platform,
				subString: "Win",
				identity: "Windows"
			},
			{
				string: navigator.platform,
				subString: "Mac",
				identity: "Mac"
			},
			{
				   string: navigator.userAgent,
				   subString: "iPhone",
				   identity: "iPhone/iPod"
		    },
			{
				string: navigator.platform,
				subString: "Linux",
				identity: "Linux"
			}
		]
	
	};
	BrowserDetect.init();


	/**** Funciones de calculo del alto / ancho de la ventana y del documento ****/
	
	function getAlturaVentana()
	{
		var windowHeight = window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight;
		return windowHeight;
	}
	
	function getAnchoVentana()
	{
		var windowWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
	windowWidth = document.viewport.getWidth();
		return windowWidth;
	}
	
	// Altura del body: en IE8 puede que no funcione exacto
	function getAlturaBody()
	{
		var body = document.documentElement || document.body;
		
		var quitarBordeSuperior = false;
		var quitarBordeInferior = false;
		if (Prototype.Browser.IE) {
			// IE: documentElement devuelve el alto de la ventana, no el del body
			body = $(document.getElementsByTagName ("body")[0]);
			
			// IE8: 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();
	
		// IE8: 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;
	}
	

	/**** Ventanas "falsas" creadas por JavaScript ****/
	
	var modal = null;  
	
	var __frameModal = null;
	var __proporcionSizeFrameModal = 0.92;

	
	// Abre un frame modal sin titulo, con la URL dada en href.
	// Si no existe la ventana o el frame no lo creará y devolverá true
	// (con lo que si el enlace está bien hecho se abrirá el href del enlace)
	function abrirFrameModal (href, idVentana, idFrame)
	{
		if (idVentana == null)  idVentana = 'ventana_modal';
		if (idFrame == null)  idFrame = 'frame_modal';
		var ventana = $(idVentana);
		var frame = $(idFrame);
		if ((ventana == null) || (frame == null)) return true;
		
		if (__frameModal == null) {
			var winClose = new Element('div', {'class': 'window_close', 'id': 'window_close'});
			winClose.onclick = function() { __frameModal.close(); };
			ventana.insert ({top: winClose});
			__frameModal = new Control.Modal(ventana,{  
		    	overlayOpacity: 0.65,  
	    		className: 'modal',  
	    		fade: true,
	    		afterClose: function() {
	    			frame.src = "";
	    		},
	            height: function() {
					var windowHeight = getAlturaVentana();
	                return (__proporcionSizeFrameModal * windowHeight);
	            },
	            width: function() {
					var windowWidth = getAnchoVentana();
	                return (__proporcionSizeFrameModal * windowWidth);
	            }
			});
		}
		frame.src = href;
		__frameModal.open();
		
		return false;
	}
  
//-->