/*
Project: HUMBOLDT GEOPISTA
File: geopistaBase.js
Author: Angel Monterde <angel.monterde.gpl@gmail.com>
Team Geopista: 
	Jorge Elia <jorgelia82@gmail.com>
	Paula Garcia <paulicagg@gmail.com>
	Pablo Gallardo <pgallardo@geopista.es>
	Juan Martin <jmartin@geopista.es>
	Angel Monterde <angel.monterde.gpl@gmail.com>	

Date: 29/05/2007
 
HUMBOLDT GEOPISTA - Light WebClient/viewer for OGC Web Map Services.
Copyright (C) 2007
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

/*
 * DEFINICIN DEL PAQUETE GEOPISTA 
 */
if(!GEOPISTA){
    var GEOPISTA = new Object();
} 
/*
 * CONTIENE LAS SIGUIENTES CLASES CLASIFICADAS:
 * -Base: Son los objetos bsicos que almacenan un mnimo de informacion. Aqu est Municipio, 
 * FormatoImagen, CapaEstilo, BBox y Servidor.
 * -Control: Son los objetos que controlan el funcionamiento del visor. Se aprovechan de las clases base.
 * Aqu pertenecen las clases Operacion, Estado y Posicion
 **************************************************************************/

/*
 * CLASES BASE:
 */
if(!GEOPISTA.Base){
    GEOPISTA.Base = new Object();
}

/**
 * @class Representa un punto en coordenadas UTM
 *
 * @constructor Crea un punto con dos miembros publicos: x y. Almacenan respectivamente  * la coordenada UTM x e y de dicho punto.
 */
GEOPISTA.Base.Punto = function(){
    /**
     * Coordenada UTM x
     */
    this.x;
    
     /**
     * Coordenada UTM y
     */
    this.y;
}

/**
 * @class Representa un bbox, el cual esta delimitado 
 *
 * @constructor Crea un bbox con cuatro miembros publicos: utmXMin, utmYMin, utmXMax y utmYMax
 * @param {float} xmin Coordenada xmin del bbox
 * @param {float} ymin Coordenada ymin del bbox
 * @param {float} xmax Coordenada xmax del bbox
 * @param {float} ymax Coordenada ymax del bbox
 */

GEOPISTA.Base.BBox = function (xmin, ymin, xmax, ymax){
    // para evitar los errores de calculo
    /**
     * Coordenada UTM x minima
     */
    this.utmXMin = xmin;
     /**
     *Coordenada UTM y minima
     */
    this.utmYMin= ymin;
    /**
     *Coordenada UTM x maxima
     */    
    this.utmXMax = xmax;
    /**
     *Coordenada UTM y maxima
     */    
    this.utmYMax = ymax;
    
    /**
     * Contenido de las variables miembro formateado para pasarlo directamente a la peticion
     * @return cadena de texto que representa las coordenadas del bbox formateadas para la petición
     * getMap
     * @type String
     */
    
    this.format = function(){
        return("&BBOX="+this.utmXMin+","+this.utmYMin+","+this.utmXMax+","+this.utmYMax);
    }
}

/**
 *
 * @class Representa el formato, el tamano, el formato y la transparencia de la imagen
 * @constructor Crea un formato de la imagen con un ancho y alto especificado.
 * @param {int} ancho Numero de pixeles de ancho de la imagen
 * @param {int} alto Numero de pixeles de alto de la imagen
 */
GEOPISTA.Base.FormatoImagen = function(ancho, alto){
    this.ancho = ancho;
    this.alto = alto;
    this.formato = "image/png";
    this.transparente = true;  
    
     /**
     * Contenido de las variables miembro formateado para pasarlo directamente a la peticion
     * @return cadena de texto que representa el alto, ancho formato y la transparencia de la imagen
     * @type String 
     */
    
    this.format = function(){
        return ("&WIDTH="+this.ancho+"&HEIGHT="+this.alto+"&FORMAT="+this.formato+"&TRANSPARENT="+this.transparente);
    }
} 

/**
 *
 * @class En esta clase se definiran las capas y estilos que se agregan a la petición.
 * @param {number} idMunicipio Valor numerico que representa el código del municipio. En el caso de IDEE el valor es null.
 * Esto se hace porque el IDEE y GEOPISTA tratan de diferente forma las capas y estilos. En GEOPISTA se añade el codigo del municipio
 * mientras que en IDEE no.
 */

GEOPISTA.Base.CapaEstilo = function(idMunicipio){
    this.idMunicipio = "";
    // Para peticion GEOPISTA
    if(idMunicipio !=null){
        this.idMunicipio = "."+idMunicipio;
    }
    var _capas = [];
    var _estilos = [];
    
    /**
     *
     *@param {String} capa Cadena que representa una capa del mapa
     *@param {String} estilo Cadena que representa un estilo de la capa 
     */
    this.addCapaEstilo = function(capa,estilo){
        if((capa!="")&&(capa!=null)&&(estilo!="")&&(estilo!=null)){
            _capas.push(capa+this.idMunicipio);
            _estilos.push(estilo);
        }
    }
    /**
    * Borra todas las capas y estilos del objeto
    */
    this.borrarTodos = function(){
        _capas.splice(0, _capas.length);		
        _estilos.splice(0, _estilos.length);
    }
    
     /**
     * Contenido de las variables miembro formateado para pasarlo directamente a la peticion
     * @return cadena de texto que representa las capas y estilos.
     * @type String 
     */
    
    this.format = function(){
        return ("&LAYERS="+_capas.join()+"&STYLES="+_estilos.join());
    }
     /**
     * Devuelve si hay capas y estilos dentro del objeto
     * @return Valor booleano que expresa si hay capas y estilos dentro
     * @type boolean
     */
    
    this.hayCapasEstilos = function(){
        if((_capas.length != 0)&&(_estilos.length!=0)){
            return true;
        }else{
            return false;
        }
    }
}

/**
 *
 * @class: Representa el servidor y la ruta de acceso al wms al que se solicitan los mapas
 * @constructor: Crea un objeto del tipo Servidor
 * @param {String} servidor URL del servidor, SIN http:// ni termina con /
 * @param {String} ruta Ruta a partir de la cual se encuentra el WMS dentro del servidor Empieza con /
 */

GEOPISTA.Base.Servidor = function(servidor, ruta){
    this.servidor = servidor;
    this.ruta = ruta;
    
    // si el servidor se encuentra actualmente disponible
    this.disponible=true;
    // el nombre del servidor cubre solo el nombre del servidor hasta el puerto. Nunca acaba con / ni empieza con http://
    // la ruta empieza siempre por el / y acaba justo antes de la interrogacion que muestra el paso de parmetros
     /**
     * Contenido de las variables miembro formateado para pasarlo directamente a la peticion
     * @return cadena de texto que representa la direccion completa del servidor con el wms
     * @type String 
     */
    this.format = function(){
        return("http://"+this.servidor+this.ruta);
    }
}

/**
 *
 * @class: Representa una peticion Get Map a un WMS que cumple el estandar OGC
 * @constructor: Crea un objeto del tipo PeticionGetMap
 * @param {GEOPISTA.Base.Servidor} servidor servidor WMS
 * @param {GEOPISTA.Base.CapaEstilo} capaEstilo las capas y estilos que se asocian a esta peticion
 * @param {String} getMapYVersion La peticion GetMap y la version
 * @param {int} id El identificador del municipio. Si es el IDEE tomara valor null
 */

GEOPISTA.Base.PeticionGetMap = function(servidor, capaEstilo, getMapYVersion, id){
    this.servidor = servidor;
    this.getMapYVersion = getMapYVersion;
    this.id = id;
    var _capaEstilo = capaEstilo;
    
     /**
     * Construye una peticion GetMap al WMS 
     * @param {String} cad_bBox Cadena que representa el bbox formateado para la peticion GetMap
     * @param {String} cad_SRS Cadena que representa el sistema de referencia espacial formateado para la peticion GetMap
     * @param {String} cad_formatoImagen Cadena que representa el formato de la imagen formateado para la peticion GetMap 
     * @return cadena de texto que representa la peticion GetMap al WMS. Si no tiene capas devuelve null
     * @type String
     */
    this.format = function(cad_bBox,cad_SRS, cad_formatoImagen){
        if((this.servidor.disponible==true)&&capaEstilo.hayCapasEstilos()){
            return(this.servidor.format()+this.getMapYVersion+_capaEstilo.format()+cad_SRS+cad_bBox+cad_formatoImagen);
        }else{
            return(null);
        }
    }
     /**
     * Elimina las capas y estilos de la peticion
     */
    this.borrarCapasEstilos = function (){
        _capaEstilo.borrarTodos();
    }
    
    /**
     * Agrega una capa y estilo asociados a esta peticion
     *@param {String} capa Cadena que representa una capa del mapa
     *@param {String} estilo Cadena que representa un estilo de la capa 
     */
    this.addCapaEstilo = function(capa, estilo){
        _capaEstilo.addCapaEstilo(capa, estilo);
    }
}

/**
 *
 * @class: Representa un conjunto de peticiones GetMap a diferentes WMS con el mismo huso horario
 * y bbox. Ademas gestiona que capas y que estilos van con cada peticion una vez que se inicializa el municipio, 
 * de forma que cada vez que se llame a addCapaEstilo sepa el solo a que peticion debe de agregar
 * dicha capa y estilo. Devuelve las peticiones a cada uno de los WMS
 * @constructor: Crea un objeto del tipo GestorPeticionesGetMap
 * @param {GEOPISTA.Base.BBox} bbox servidor WMS
 * @param {GEOPISTA.Base.FormatoImagen} formatoImagen las capas y estilos que se asocian a esta peticion
 * @param {String} srs El sistema de referencia geoespacial
 */

GEOPISTA.Base.GestorPeticionesGetMap = function(bbox, formatoImagen, srs){
    var _peticiones = [];
    this.bbox = bbox;
    this.formatoImagen = formatoImagen;
    this.srs = srs; 
    
    var _gestorPeticionesConCapas = [];
    
     /**
     * Inicializa el conjunto de peticiones que dispone el visor
     *@param {Object} peticionesServidores Es el conjunto de peticiones con sus capas, estilos 
     * y servidor que tiene gestionara este objeto. El formato es del tipo: 
                {"peticiones":[
		{"id": GEOPISTA_TOPONIMOS, "servidor": GEOPISTA.Base.SERVIDOR_GEOPISTA, "versionGetMap": GEOPISTA.Base.GET_MAP_VERSION_1_1_1,"zIndex": 5, "idMunicipio":GEOPISTA.Base.ID_MUNICIPIO, "capasYEstilos":[
			{"capa":GEOPISTA.Base.CapaEstilo.C_PARCELAS_URBANAS, "estilo":GEOPISTA.Base.CapaEstilo.E_PARCELAS_URBANAS, "siempreVisible": false, "idLeyenda": "numerosDePolicia"}
                 ]}
                ]};
     */
    
    this.inicializaMunicipio = function(peticionesServidores){
        for(var i=0; i<peticionesServidores.peticiones.length; i++){
            var capaEstilo = new GEOPISTA.Base.CapaEstilo(peticionesServidores.peticiones[i].idMunicipio);
            //console.log(peticionesServidores.peticiones[i].idMunicipio);
            //debugger;
            // recorremos las capas y estilos de dicha peticion
            var capa = null;
            var estilo = null;
            //debugger;
            for (var j = 0; j<peticionesServidores.peticiones[i].capasYEstilos.length; j++){
                capa = peticionesServidores.peticiones[i].capasYEstilos[j].capa;
                estilo = peticionesServidores.peticiones[i].capasYEstilos[j].estilo;
                //console.log("Capa:"+capa);
                //console.log("Estilo:"+estilo);
                //capaEstilo.addCapaEstilo(capa, estilo);
                
                var peticionCapa = new Object();
                
                // es un identificador v�ido para el usuario, no para nuestro vector de almacenamiento.
                peticionCapa.idPeticion = peticionesServidores.peticiones[i].idPeticion;
                // para saber en qu�posici� est�dicha petici�
                peticionCapa.posicion = i;
                peticionCapa.capa = peticionesServidores.peticiones[i].capasYEstilos[j].capa;
                peticionCapa.estilo = peticionesServidores.peticiones[i].capasYEstilos[j].estilo;
                peticionCapa.siempreVisible = peticionesServidores.peticiones[i].capasYEstilos[j].siempreVisible;
                peticionCapa.pedidaPorUsuario = true; // para que en la primera petici� tengamos esa capa 
                _gestorPeticionesConCapas.push(peticionCapa);
            }
            var miPeticion = new GEOPISTA.Base.PeticionGetMap(
            peticionesServidores.peticiones[i].servidor,capaEstilo, 
            peticionesServidores.peticiones[i].versionGetMap, 
            peticionesServidores.peticiones[i].idPeticion);
            
            _peticiones.push(miPeticion);
             /*console.log("--------------------------");
             console.log("Peticion Metida:");
             console.log("peticionesServidores.peticiones[i].servidor"+peticionesServidores.peticiones[i].servidor);
             console.log("peticionesServidores.peticiones[i].versionGetMap"+peticionesServidores.peticiones[i].versionGetMap);
             console.log("peticionesServidores.peticiones[i].id"+peticionesServidores.peticiones[i].idPeticion);
              */
        }
    }
    
    /**
     *	Tras realizar una peticin se borran todas las capas y estilos que existieran, 
     *por lo que ser necesario agregar antes de realizar una peticin las capas y estilos
     *necesarios, ya que si no hay capas ni estilos no se realiza la peticin.
     *@param {String} capa Cadena que representa una capa del mapa
     *@param {String} estilo Cadena que representa un estilo de la capa 
     *@param {int} idPeticion identificador de la peticion a la cual se le agrega la capa y el estilo
     */
    
    
    this.addCapaEstilo = function(capa, estilo, idPeticion){
        /*for(var i=0; i<peticiones.length; i++){
            if(peticiones[i].id == idPeticion ){
                peticiones[i].addCapaEstilo(capa, estilo);
            }
        }*/
        /*
console.log("-----------------------------------------------------------");
console.log("ADD CAPA ESTILO");
console.log("-----------------------------------------------------------");*/
        for(var i=0; i<_gestorPeticionesConCapas.length; i++){
            if((_gestorPeticionesConCapas[i].idPeticion==idPeticion)&&
            (_gestorPeticionesConCapas[i].capa == capa)){
                _gestorPeticionesConCapas[i].pedidaPorUsuario = true;
                //console.log("      "+_gestorPeticionesConCapas[i].capa);
                // ya hemos a�dido la capa, por lo que salimos del m�odo
                return;
            }
        }
    }
    
     /**
     *	Se borran las capas y estilos de todas las peticiones para dejarlas limpias para la proxima peticion
     */
    
    this.borrarCapasEstilos = function(){
    /*
console.log("-----------------------------------------------------------");
console.log("BORRAR CAPA ESTILO");
console.log("-----------------------------------------------------------");*/
        for(var i=0; i<_peticiones.length; i++){
            //debugger;
            _peticiones[i].borrarCapasEstilos();
/*
console.log("      "+_gestorPeticionesConCapas[i].capa);
            if(_gestorPeticionesConCapas[i].siempreVisible == false){
                _gestorPeticionesConCapas[i].pedidaPorUsuario = false;
console.log("                       pedidoUsuario false");
            }*/
        }
        for(var i=0; i<_gestorPeticionesConCapas.length; i++){
            if(_gestorPeticionesConCapas[i].siempreVisible==false){
                _gestorPeticionesConCapas[i].pedidaPorUsuario = false;
            }
        }
    }
    
    /**
     * Es llamado por GestorImagenes para recuperar las peticiones de los mapas
     * @return devuelve el conjunto de peticiones getMap formateadas para perdirlas al WMS
     * @type String[]
     */
    this.getPeticionesMapas = function(){
        var peticionesMapas = [];
        // cacheamos las variables formateadas
        var cad_bbox = this.bbox.format();
        var cad_formatoImagen = this.formatoImagen.format();
        // a�dimos antes las capas y estilos a cada peticion
        for(var i=0; i<_gestorPeticionesConCapas.length; i++){
            if((_gestorPeticionesConCapas[i].pedidaPorUsuario==true)||(_gestorPeticionesConCapas[i].siempreVisible==true)){
                var capa = _gestorPeticionesConCapas[i].capa;
                var estilo = _gestorPeticionesConCapas[i].estilo;
                var posicion = _gestorPeticionesConCapas[i].posicion;
                _peticiones[posicion].addCapaEstilo(capa,estilo);
                //peticiones[_gestorPeticionesConCapas[i].idPeticion].addCapaEstilo(_gestorPeticionesConCapas[i].capa, _gestorPeticionesConCapas[i].estilo);
            }
        }
        
        for(var i=0; i<_peticiones.length; i++){
            var peticionFormateada = new Object();
            //alert();
            // ponemos un identificador a cada petici� del mapa que devolvemos
            peticionFormateada.id = _peticiones[i].id;
            if(_peticiones[i].servidor.disponible==true){
                peticionFormateada.formato = _peticiones[i].format(cad_bbox, this.srs, cad_formatoImagen)
            }else{
                peticionFormateada.formato = null;
            }
            peticionesMapas.push(peticionFormateada);
        }
        return peticionesMapas;
    }
     /**
     * Devuelve la relacion del tamano de la imagen. Para ello divide los pixeles x entre los pixeles y
     * @return devuelve el conjunto de peticiones getMap formateadas para perdirlas al WMS
     * @type float
     */
    this.getRelacionXDivididoY = function(){
        return(this.formatoImagen.ancho/this.formatoImagen.alto);
    }
}

/**
 *
 * @class Esta clase gestiona la recuperacion de las imagenes de los mapas y como se muestran estos en el visor.
 * Las peticiones de los mapas las obtiene del gestorPeticion. Tiene un gestor de coordenadas para saber la posicion
 * en la que esta actualmente. 
 * @constructor: Crea un objeto del tipo GestorImagenes
 * @param {GEOPISTA.Base.GestorPeticionesGetMap} gestorPeticion Es el encargado de construir las peticiones a los diferentes servidores.
 * @param {GEOPISTA.Base.GestorCoordenadas} gestorCoordenada Lleva el control de las coordenadas de las peticiones
 * @param {boolean} IE Indica si el navegador es internet explorer 6 o no
 * @param {div} capaPadreMapas Es un puntero a la capa padre donde se colocan los mapas.
 * @param {boolean} conCapaCargando Indica si se crea una capa encima de las capas del mapa. Sirve para colocar encima la barra de progreso
 */

GEOPISTA.Base.GestorImagenes = function(gestorPeticion, gestorCoordenada, IE, capaPadreMapas, conCapaCargando){
    var _gestorPeticiones = gestorPeticion;
    
    var _gestorCoordenadas = gestorCoordenada;
    
    var _isIE = IE;
    var _precargaImagenes = [];
    var _isTodosMapasCargados = false;
    // cuando usemos la mano las capas se desplazar�, esta variable tomar�valor true,
    // lo que habr�que hacer es dejar las capas en su sitio
    //var isCapasMapasDesplazadas = false;
    var _capaPadre = capaPadreMapas;
    var _capaOperacion = null;
    var _capaMapas = null;
    var _imagenBlanco = null;
    
    var _objetoAMostrarMientrasSeCargaPeticion = null;
    var _capaObjetoAMostrarMientrasSeCargaPeticion = null;
    
    var _cursorActual = null;
    
    var _timer = null;
    var _delay = 60000;
    if(conCapaCargando){
        _capaObjetoAMostrarMientrasSeCargaPeticion = document.createElement("div");
    }
    /*
     * var parametrosCapasPeticiones = {"capaMapas":"capaMapas", "capaOperacion":"capaOperacion",
      "width":"792px", "height":"540px", "position":"absolute","top":"0px", "left":"0px", 
      "imgBlanca":"img/blank.gif", "peticiones":[
            {"idPeticion": GEOPISTA_BASE, "zIndex": 2},
            {"idPeticion": GEOPISTA_TOPONIMOS, "zIndex": 5},
            {"idPeticion": IDEE, "zIndex": 3}, 
            ]
     };
     */
    
     /**
     * Inicializa las capas sobre las cuales se mostraran las imagenes del mapa. Cada peticion tiene su propia
     * capa. Todas las capas tienen las mismas dimensiones y posicionamiento. Ademas se pasa la imagen en blanco
     * para que si alguna peticion da error o se retrasa mucho salga en su lugar la imagen en blanco. 
     * @param {String[]} parametrosCapasPeticiones Almacena la posicion y dimensiones de todas las capas de las peticiones
     * Ademas se especifica la posicion de colocamiento (la que estara mas abajo y sera "ocultada" por las otras y la que
     * estara mas arriba que se mostrara sobre las otras) del zindex.
     */ 
  
    
    this.initCapas = function(parametrosCapasPeticiones){
        // cacheamos los valores fijos
        var w = parametrosCapasPeticiones.width;
        var h = parametrosCapasPeticiones.height;
        var p = parametrosCapasPeticiones.position;
        var t = parametrosCapasPeticiones.top;
        var l = parametrosCapasPeticiones.left;
        _imagenBlanco = parametrosCapasPeticiones.imgBlanca;
        
        // si no tenemos la capaOperacion ni capaMapas:
        if((_capaOperacion==null)||(_capaMapas == null)){
            _capaOperacion = document.createElement("div");
            _capaMapas = document.createElement("div");
            
            //capaOperacion.id="capaOperacion";
            _capaOperacion.setAttribute('id','capaOperacion');
            _capaMapas.setAttribute('id','capaMapas');
            
            _capaOperacion.style.width = w;
            _capaMapas.style.width = w;
            
            _capaOperacion.style.height = h;
            _capaMapas.style.height = h; 
            
            _capaOperacion.style.top = t;
            _capaMapas.style.top = t;
            
            _capaOperacion.style.left = l;
            _capaMapas.style.left = l;
            
            _capaOperacion.style.position = p;
            _capaMapas.style.position = p;
            
            _capaOperacion.style.zIndex = 200;
            _capaMapas.style.zIndex = 1;
            
            _capaMapas.style.backgroundImage="url("+_imagenBlanco+")";
            _capaOperacion.style.backgroundImage="url("+_imagenBlanco+")";//+imagenBlanco+
            
            //if(_isIE==true){
                _capaMapas.setAttribute('unselectable', 'on');
                _capaOperacion.setAttribute('unselectable', 'on');
                //capaMapas.unselectable="on";
                //capaOperacion.unselectable="on";
            //}
            
            _capaPadre.appendChild(_capaOperacion);
            _capaPadre.appendChild(_capaMapas);
        }
        
        if(conCapaCargando!=null){
            //_capaObjetoAMostrarMientrasSeCargaPeticion = document.createElement("div");
            _capaObjetoAMostrarMientrasSeCargaPeticion.style.width = w;
            _capaObjetoAMostrarMientrasSeCargaPeticion.style.height = h;
            _capaObjetoAMostrarMientrasSeCargaPeticion.style.top = t;              
            _capaObjetoAMostrarMientrasSeCargaPeticion.style.left;
            _capaObjetoAMostrarMientrasSeCargaPeticion.style.position = p;
            _capaObjetoAMostrarMientrasSeCargaPeticion.style.zIndex = 500;
            if(_isIE==true){
                _capaObjetoAMostrarMientrasSeCargaPeticion.unselectable="on";
            }
            _capaPadre.appendChild(_capaObjetoAMostrarMientrasSeCargaPeticion);
        }
        for(var i=0; i<parametrosCapasPeticiones.peticiones.length; i++){
            var capa;
            if(_isIE==true){
                capa = document.createElement("img");
                capa.setAttribute('src', _imagenBlanco);
            }else{
                capa = document.createElement("div");
            }
            capa.setAttribute('unselectable', 'on');
            
            capa.setAttribute('id', parametrosCapasPeticiones.peticiones[i].idPeticion); 
            
            capa.style.width = w;
            capa.style.height = h;   
            capa.style.top = t;
            capa.style.left = l;  
            capa.style.position = p;
            capa.style.zIndex = parametrosCapasPeticiones.peticiones[i].zIndex; 
            
            _capaMapas.appendChild(capa);
            
        }
    }
    
    // para saber a qu�capa ir� destinados los eventos
    /**
     * Devuelve la capa receptora de eventos, que es la capaOperacion
     * @return Devuelve la capa operacion.
     * @type div
     */
    this.getCapaOperacion = function(){
        return _capaOperacion;
    }
    /**
     * Devuelve la capa padre de los mapas. Es necesaria para la mano, ya que esta tiene que
     * mover todas las capas de las imagenes a la vez
     * @return Devuelve la capa padre de los mapas.
     * @type div
     */
    this.getCapaMapas = function(){
        return _capaMapas;
    }
    /**
     * Introduce el objeto que se mostrara mientras se esta cargando el mapa
     * @param {GEOPISTA.Base.ObjetoAMostrarMientrasSeCargaPeticion} objeto El objeto que se mostrara mientras se cargan los mapas
     */
    
    this.setObjetoAMostrarMientrasSeCargaPeticion = function(objeto){
        _objetoAMostrarMientrasSeCargaPeticion = objeto;
    }

     /**
     * Devuelve el objeto que se mostrara mientras se esta cargando el mapa
     * @return  objeto El objeto que se mostrara mientras se cargan los mapas
     * @type GEOPISTA.Base.ObjetoAMostrarMientrasSeCargaPeticion
     */
    
    this.getCapaObjetoAMostrarMientrasSeCargaPeticion = function(){
        return(_capaObjetoAMostrarMientrasSeCargaPeticion);
    }
    
/**
 * Hace una precarga de las imagenes. Cuando se lance el evento onload de todas las imagenes
 * entonces se muestra el mapa. Internamente llama al gestorPeticiones para que le devuelva todas
 * las peticiones que tiene que realizar a los WMS. Una vez tenidas, llama al vector de imagenes de precarga para
 * que soliciten dichas imagenes, y cuando esten todas cargadas actualiza cada capa del mapa con la nueva imagen
 */
    
    this.cargaMapas = function(){
        // escondemos la capaOperacion para que no se puedan lanzar los eventos de pinchar en el mapa
        //capaOperacion.style.zIndex = 1;
        // dejamos todas las imagenes sin cargar:
        _isTodosMapasCargados = false;
        for(var i=0; i<_precargaImagenes.length; i++){
            _precargaImagenes[i].isCargada= false;
        }
        // realizamos la nueva petici�
        var peticiones = _gestorPeticiones.getPeticionesMapas();
        
        // si no tenemos ninguna imagen creada porque es la primera peticion:
        if(_precargaImagenes.length == 0){
            for(var i=0; i<peticiones.length; i++){
                var nuevaImagen = new Image();
                
                nuevaImagen.isCargada = false;
                nuevaImagen.idPeticion = peticiones[i].id;
                nuevaImagen.seguirPidiendola = true;
                
                _precargaImagenes.push(nuevaImagen);
                // conectamos los distintos eventos: onload, on error, onabort:
                dojo.event.kwConnect({srcObj:_precargaImagenes[i], srcFunc:"onload", adviceObj: this,
                adviceFunc:"imagenOnLoad", once:true});
                
                dojo.event.kwConnect({srcObj:_precargaImagenes[i], srcFunc:"onerror", adviceObj: this,  
                adviceFunc:"imagenOnError", once:true});
                // si abortan la peticion
                dojo.event.kwConnect({srcObj:_precargaImagenes[i], srcFunc:"onabort", adviceObj: this, 
                adviceFunc:"imagenOnAbort", once:true});
            }
        }
        
        for(var i=0; i<peticiones.length; i++){
            for(var j=0; j< _precargaImagenes.length; j++){
                //alert("precargaId:"+ _precargaImagenes[j].idPeticion +"peticiones.id"+peticiones[i].id);
                if(_precargaImagenes[j].idPeticion == peticiones[i].id){
                    if(_precargaImagenes[i].seguirPidiendola==true){
                        _precargaImagenes[j].src = peticiones[i].formato;
                    }else{
                        _precargaImagenes[j].src = _imagenBlanco;
                    }
                    // pasamos a la siguiente petici�
                    //console.log(_precargaImagenes[i].src);
                    break;
                }
            }
        }
        _cursorActual = _capaPadre.style.cursor;
        _capaPadre.style.cursor = "wait";
        // mostramos la barra de progreso o lo que sea
        if(_objetoAMostrarMientrasSeCargaPeticion!=null){
            _objetoAMostrarMientrasSeCargaPeticion.setVisible(true);
        }
        
        _timer = dojo.lang.setTimeout(this, "timeoutPeticiones", _delay);   
        //setTimeout(_that.timeoutPeticiones, _delay);//
    }
    
    /**
    *
    * @param {evt} evt Imagen que tras lanzar el evento onload se pasa a imagenOnLoad para
    * comprobar si el resto de las imagenes estan cargadas o no. Se une por dojo el onload de la 
    * imagen con el de esta funcion.
    */
    
    this.imagenOnLoad = function(evt){
        //alert("imagen cargada:"+evt.currentTarget.idPeticion);
        // marcamos la imagen como cargada
        evt.currentTarget.isCargada = true;
        
        for(var i=0; i<_precargaImagenes.length; i++){
            if(_precargaImagenes[i].isCargada==false){
                return;
            }
        }
        // est� todas las peticiones cargadas
        _isTodosMapasCargados = true;
        this.mostrarMapas();
    }
    

    /**
    *
    * @param {evt} evt Imagen que tras lanzar el evento onerror se pasa a imagenOnError para
    * comprobar si el resto de las imagenes estan cargadas o no. Se une por dojo el onerror de la 
    * imagen con el de esta funcion.
    */
    
    this.imagenOnError = function(evt){
        //alert("imagen cargada:"+evt.currentTarget.idPeticion);
        // marcamos la imagen como cargada
        //alert("error");
        evt.currentTarget.isCargada = true;
        // evt.currentTarget.src=""; // cuelga el IE
        evt.currentTarget.src=_imagenBlanco;
        evt.currentTarget.alt="";
        for(var i=0; i<_precargaImagenes.length; i++){
            if(_precargaImagenes[i].isCargada==false){
                return;
            }
        }
        // est� todas las peticiones cargadas
        _isTodosMapasCargados = true;
        this.mostrarMapas();
    }
    
    
    /**
    *
    * @param {evt} evt Imagen que tras lanzar el evento onabort se pasa a imagenOnAbort para
    * comprobar si el resto de las imagenes estan cargadas o no. Se une por dojo el onabort de la 
    * imagen con el de esta funcion.
    */
    this.imagenOnAbort = function(evt){
        //alert("imagen cargada:"+evt.currentTarget.idPeticion);
        // marcamos la imagen como cargada
        evt.currentTarget.isCargada = true;
        evt.currentTarget.src=_imagenBlanco;
        evt.currentTarget.alt="";
        for(var i=0; i<_precargaImagenes.length; i++){
            if(_precargaImagenes[i].isCargada==false){
                return;
            }
        }
        // est� todas las peticiones cargadas
        _isTodosMapasCargados = true;
        this.mostrarMapas();
    }
    
    
    /**
    *
    * Primero se ha solicitado cargar las imagenes con el metodo cargaMapas. 
    * Si se acaba el tiempo establecido por el contador interno _delay entonces se 
    * llama a este metodo. Lo que hace es por cada peticion que no ha sido cargada
    * preguntar al usuario que desea hacer con la peticion, si seguir esperando o si
    * cancelar la carga. Si quiere cancelar la carga se le pregunta si cancela dicha
    * peticion para siempre. 
    */
    this.timeoutPeticiones = function(){
        var continuarEsperando = false;
        for(var i=0; i< _precargaImagenes.length; i++){
            if(_precargaImagenes[i].isCargada == false){
                var mensajeConfirmacion = "Ha transcurrido el tiempo de espera al servidor. Es posible que el servidor "+ 
                _precargaImagenes[i].idPeticion+ " no este disponible. Para cancelar la carga del servidor pulse Aceptar. Si desea seguir esperando pulse Cancelar";
                var finalizarCarga = confirm(mensajeConfirmacion);
                if(finalizarCarga == true){
                    _precargaImagenes[i].src = _imagenBlanco;
                    _precargaImagenes[i].isCargada = true;
                    var capaDescartada = confirm("Desea descartar esta capa en las siguientes peticiones?");
                    if(capaDescartada==true){
                        _precargaImagenes[i].seguirPidiendola = false;
                    }
                }else{
                    continuarEsperando = true;
                    _timer = dojo.lang.setTimeout(this, "timeoutPeticiones", _delay);
                }
            }
        }
        
        if(continuarEsperando==false){
            this.mostrarMapas();
        }
    }
    
    // es para hacer el dojo.event.KwConnect de que el mapa ya est�cargado y se puede reajustar las chinchetas
    
    /**
     * Se llama cuando todas las imagenes estan cargadas (bien sea porque se han completado por el onload,
     * onabort u onerror, o bien el usuario haya cancelado la carga). Ahora se cancela el timeout y 
     * se para la barra de progreso y se muestran todas las imagenes.
     */
    this.mostrarMapas = function(){ 
        // limpiamos el temporizador
        dojo.lang.clearTimeout(_timer);   
        // parar la barra de progreso
        if(_objetoAMostrarMientrasSeCargaPeticion!=null){
            _objetoAMostrarMientrasSeCargaPeticion.setVisible(false);
        }
        // poner la imagen precargada en su capa asociada
        var hijos = null;
        //debugger;
        if(_isIE){
            // obtenemos los hijos
            hijos = _capaMapas.getElementsByTagName("img");
            for(var i=0; i<_precargaImagenes.length; i++){
                for(var j=0; j<hijos.length; j++){
                    if(hijos[j].id == _precargaImagenes[i].idPeticion){
                        hijos[j].src = _precargaImagenes[i].src;
                        
                        var t = hijos[j].src;
                        hijos[j].src = _imagenBlanco;
                        hijos[j].runtimeStyle.filter="progid:DXImageTransform.Microsoft.AlphaImageLoader(src='"+t+"',sizingMethod='scale')";
                        break;
                    }
                }
            }
        }else{
            hijos = _capaMapas.getElementsByTagName("div");
            for(var i=0; i<_precargaImagenes.length; i++){
                for(var j=0; j<hijos.length; j++){
                    if(hijos[j].id == _precargaImagenes[i].idPeticion){
                        hijos[j].style.backgroundImage = 'url('+_precargaImagenes[i].src+')';
                        break;
                    }
                }
            }
        }
        
        // si las capas est� movidas las dejamos en su lugar:
        topCapaMapas = parseInt(_capaMapas.style.top);
        leftCapaMapas = parseInt(_capaMapas.style.left);
        if((topCapaMapas!=0)||(leftCapaMapas!=0)){
            _capaOperacion.style.top = "0px";
            _capaOperacion.style.left = "0px";
            _capaMapas.style.top = "0px";
            _capaMapas.style.left = "0px";
        }
        _capaPadre.style.cursor = _cursorActual;
        // tras mostrar las imagenes, tenemos que actualizar las coordenadas:
        //                                                  bbox,                   longitudX,              longitudY)
        _gestorCoordenadas.setEscala(_gestorPeticiones.bbox, parseInt(_capaPadre.style.width), parseInt(_capaPadre.style.height));
        //capaOperacion.style.zIndex = 200;
        //debugger;
        //this.avisadorMapasCargados(null);
    }
    
    
    this.isTodosMapasCargados = function(){
        return _isTodosMapasCargados;
    }

    this.getEscala = function(){
        return(_gestorCoordenadas.getEscala());
    }

////////////////////////////////////////////////////////////////////////////////    
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
    
    this.getPuntoActual = function(evt){
        return (_gestorCoordenadas.getPuntoActual(evt));
    }
    this.getBBox = function(evt){
        return (_gestorCoordenadas.getBBox());
    }
    this.getRelacionLongitudPixelesMapaConPixelesImagen = function(){
        return(_gestorCoordenadas.getRelacionLongitudPixelesMapaConPixelesImagen());
    }

    this.setBBox = function(bbox){
        _gestorPeticiones.bbox = bbox;
    }
    this.setFormatoImagen = function(formatoImagen){
        _gestorPeticiones.formatoImagen = formatoImagen;
    }
    
    this.addCapaEstilo = function(capa, estilo, idPeticion){
        _gestorPeticiones.addCapaEstilo(capa, estilo, idPeticion);
    }
    
    this.borrarCapasEstilos = function(){
        _gestorPeticiones.borrarCapasEstilos();
    }
    
    this.getRelacionXDivididoY = function(){
        return(_gestorPeticiones.getRelacionXDivididoY());
    }
    
    this.getFormatoImagen = function(){
        return(_gestorPeticiones.formatoImagen);
    }

    
////////////////////////////////////////////////////////////////////////////////    
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
    
}

/**
 * 
 * @class Es la encargada de recuperar las coordenadas del bbox contenido en funcion
 * de las dimensiones de las de la imagen del mapa en pixeles. 
 * @param {GEOPISTA.Base.BBox} bbox Es el bbox que se muestra actualmente
 * @param {float} longitudX longitud coordenadas X en pixeles del mapa
 * @param {float} longitudY longitud coordenadas Y en pixeles del mapa
 */


GEOPISTA.Base.GestorCoordenadas = function(bbox, longitudX, longitudY){
    this.DESPLAZAMIENTO_X = 0;
    this.DESPLAZAMIENTO_Y = 0;
    
    var _bbox = bbox;
    var _longitudPixelesImagenX = longitudX;
    var _longitudPixelesImagenY = longitudY;
    
    var _utmXMin = _bbox.utmXMin;
    var _utmYMax = _bbox.utmYMax;
    var _distX = _bbox.utmXMax - _bbox.utmXMin;
    var _distY = _bbox.utmYMax - _bbox.utmYMin;
    var _pixelesPorCentimetro = 1080/28.5;
    
    var _puntoActual = new GEOPISTA.Base.Punto();
    
    /**
    *
    * A partir del evento encapsulado por dojo, el cual almacena las coordenadas x,y del raton
    * se obtiene la posicion del punto actual del raton.
    * @param {evt} evt evento de dojo 
    */ 
    this.getPuntoActual = function(evt){
				//       |--coord X min|---- desplazamiento rat�-------| |---escalaPxImagenConDistancia---|
        var x = _utmXMin + ((evt.pageX - this.DESPLAZAMIENTO_X)/(_longitudPixelesImagenX/_distX));
        var y = _utmYMax - ((evt.pageY - this.DESPLAZAMIENTO_Y)/(_longitudPixelesImagenY/_distY));
        _puntoActual.x = x;
        _puntoActual.y = y;
        
        return (_puntoActual);
    }
    
    /**
    * 
    * Devuelve la escala actual del mapa 
    * @return numero decimal que representa la escala
    * @type float 
    */ 
    this.getEscala = function(){
        //Math.ceil(bboxActual.getDistanciaX()/(cmMapa/100));
        var cmMapa = _longitudPixelesImagenX / _pixelesPorCentimetro;
        return(Math.ceil(_distX/(cmMapa/100)));
    }
    /**
    *
    * Devuelve la relacion entre la longitud de pixeles del mapa con los pixeles de la imagen
    * @return numero decimal que representa la relacion
    * @type float      
    */ 
    this.getRelacionLongitudPixelesMapaConPixelesImagen = function(){
        return(_longitudPixelesImagenX /_distX);
    }

    /**
    *
    * Cambia la escala del gestor de coordenadas. Hay que hacerlo cada vez que se cambie el bbox
    * @param {GEOPISTA.Base.BBox} bbox Es el nuevo bbox del gestor de coordenadas, sobre el cual se calcularan los diferentes puntos de la imagen en funcion de las dimensiones de la imagen
    * @param {float} longitudX Anchura en pixeles de la imagen
    * @param {float} longitudY Altura en pixeles de la imagen
    */     
    
    this.setEscala = function(bbox, longitudX, longitudY){
        _bbox = bbox;
        _longitudPixelesImagenX = longitudX;
        _longitudPixelesImagenY = longitudY;
        _utmXMin = _bbox.utmXMin;
        _utmYMax = _bbox.utmYMax;
        _distX = _bbox.utmXMax - _utmXMin;
        _distY = _utmYMax - _bbox.utmYMin;
        
    }
    
    /**
    * 
    * Cada vez que se vaya ha realizar una peticion antes hay que recuperar el bbox actual. 
    *  El bbox actual se almacena unicamente en el gestor de coordenadas para tenerlo todo centralizado 
    * @return El bbox actual
    * @type  GEOPISTA.Base.BBox
    */ 
    this.getBBox = function(){
        return _bbox;
    }
}

/**
*
* Almacena todos los datos de las peticiones GetMap y GetFeatureInfo. Esta estructurado para una
* futura ampliacion de un mapa guia cuando este se pueda implementar. 
* @param {GEOPISTA.Base.GestorImagenes} gestorImagenesMapa se encarga de gestionar todos las operaciones GetMap
* y la gestion de dichas peticiones del Mapa 
* @param {GEOPISTA.Base.GestorImagenes} gestorImagenesGuia Actualmente se pone a null. Sera para el mapa guia
* @param {GEOPISTA.Base.PeticionFeatureInfo} peticionGetFeatureInfo Peticion getFeatureInfo para cuando se pueda desarrollar esta
*/ 
GEOPISTA.Base.ModeloCargaImagenesPeticiones = function(gestorImagenesMapa, 
gestorImagenesGuia, peticionGetFeatureInfo){
    
    var _gestorImagenesMapa = gestorImagenesMapa;
    var _gestorImagenesGuia = gestorImagenesGuia;
    var _peticionGetFeatureInfo = peticionGetFeatureInfo;
    this.ayuntamiento;
    
    this.cargaMapas = function(aPeticiones){
        if(aPeticiones){
            _gestorImagenesMapa.cargaMapas();
        }else{
            _gestorImagenesGuia.cargaMapas();
        }
    }

    /*
     *Metodos que son propios de gestorImagenes
     */
    this.getCapaOperacion = function(aPeticiones){
        if(aPeticiones){
            return _gestorImagenesMapa.getCapaOperacion();
        }else{
            return _gestorImagenesGuia.getCapaOperacion();
        }
    }
    this.getCapaMapas = function(aPeticiones){
        if(aPeticiones){
            return _gestorImagenesMapa.getCapaMapas();
        }else{
            return _gestorImagenesGuia.getCapaMapas();
        }
    }
    
    this.isTodosMapasCargados = function(aPeticiones){
        if(aPeticiones){
            return _gestorImagenesMapa.isTodosMapasCargados();
        }else{
            return _gestorImagenesGuia.isTodosMapasCargados();
        }
    }
    /*
     * M�odos que son propios de gestorCoordenadas
     */
    this.getEscala = function(aPeticiones){
        if(aPeticiones){
            return _gestorImagenesMapa.getEscala();
        }else{
            return _gestorImagenesGuia.getEscala();
        }
    }
    
    this.getRelacionLongitudPixelesMapaConPixelesImagen = function(aPeticiones){
        if(aPeticiones){
            return _gestorImagenesMapa.getRelacionLongitudPixelesMapaConPixelesImagen();
        }else{
            return _gestorImagenesGuia.getRelacionLongitudPixelesMapaConPixelesImagen();
        }
    }
    
    this.getPuntoActual = function(evt, aPeticiones){
        if(aPeticiones){
            return (_gestorImagenesMapa.getPuntoActual(evt));
        }else{
            return (_gestorImagenesGuia.getPuntoActual(evt));
        }
    }
    
    this.getBBox = function(aPeticiones){
        if(aPeticiones){
            return (_gestorImagenesMapa.getBBox());
        }else{
            return (_gestorImagenesGuia.getBBox());
        }
    }
    /*
     * M�odos que son propios de gestorPeticiones
     */
    this.setBBox = function(bbox, aPeticiones){
        if(aPeticiones){
            _gestorImagenesMapa.setBBox(bbox);
        }else{
            _gestorImagenesGuia.setBBox(bbox);
        }
    }
    
    this.setFormatoImagen = function(formatoImagen, aPeticiones){
        if(aPeticiones){
            _gestorImagenesMapa.setFormatoImagen(formatoImagen);
        }else{
            _gestorImagenesGuia.setFormatoImagen(formatoImagen);
        }
    }
    
    this.getRelacionXDivididoY = function(aPeticiones){
        if(aPeticiones){
            return _gestorImagenesMapa.getRelacionXDivididoY();
        }else{
            return _gestorImagenesGuia.getRelacionXDivididoY();
        }
    }
    /*
     * Cada PeticionGetMap posee un id que lo identifica del resto
     */
    this.addCapaEstilo = function(capa, estilo, idPeticion, aPeticiones){
        if(aPeticiones){
            _gestorImagenesMapa.addCapaEstilo(capa, estilo, idPeticion);
        }else{
            _gestorImagenesGuia.addCapaEstilo(capa, estilo, idPeticion);
        }
    }
    
    this.borrarCapasEstilos = function(aPeticiones){
        if(aPeticiones){
            _gestorImagenesMapa.borrarCapasEstilos();
        }else{
            _gestorImagenesGuia.borrarCapasEstilos();
        }
    }
    
    // sera llamado por gestorOperaciones antes de que llame a getFeatureInfo.
    // es decir, cuando haga onclick sobre la capa operacion, sera invocado
    // un metodo del gestorOperaciones que inicializara estos campos y 
    // llamara a getFeatureInfo
    this.getFeatureInfo = function(capa, campos, x, y){
        //debugger;
        _peticionGetFeatureInfo.setCapaConCampos(capa, campos);
        _peticionGetFeatureInfo.bbox = this.getBBox(true);
        var formatoImagen = _gestorImagenesMapa.getFormatoImagen();
        _peticionGetFeatureInfo.width = formatoImagen.ancho;
        _peticionGetFeatureInfo.height = formatoImagen.alto;
        return (_peticionGetFeatureInfo.getPeticionFeatureInfo(x,y));
    }
}
/////////////////////////////////////////

GEOPISTA.Base.PeticionFeatureInfo = function(servidor, ruta, versionConPeticion, 
featureCount, formatoInfo, srs, idMunicipio){
    var _servidor = servidor;
    var _ruta = ruta;
    var _versionConPeticion = versionConPeticion;
    var _featureCount = featureCount;
    var _formatoInfo = formatoInfo;
    var _imageFormat = "image/png";
    var _srs = srs;
    var _idMunicipio = idMunicipio;
    
    var _capa;
    var _campos = [];
    
    this.bbox;
    this.width;
    this.height;
    
    this.setCapaConCampos = function(capa, campos){
        _capa = capa;
        _campos = campos;
    }
    
    this.getPeticionFeatureInfo = function(x,y){
        var peticion = "";
        
        var cadBBox = this.bbox.format();
        var cadServidor = "http://"+_servidor;
        var cadWidth = "&WIDTH="+this.width;
        var cadHeight = "&HEIGHT="+this.height;
        var cadFormatoInfo = "&INFO_FORMAT="+_formatoInfo;
        var cadCapa = "&LAYERS="+_capa;
        var cadCapaQuery = "&QUERY_LAYERS="+_capa;
        if(_idMunicipio!=null){
            cadCapa += "."+_idMunicipio;
            cadCapaQuery+="."+_idMunicipio;
        }
        var cadImageFormat = "&FORMAT="+_imageFormat;
        var cadSrs = _srs;
        
        var cadFeatureCount = "&FEATURE_COUNT="+_featureCount;
        
        var cadX = "&X="+x;
        var cadY = "&Y="+y;
        peticion = cadServidor+ _ruta + _versionConPeticion+cadBBox + cadWidth +
        cadHeight + cadFormatoInfo + cadCapa + cadImageFormat + cadSrs 
        +cadCapaQuery+cadFeatureCount+cadX+cadY; 
//debugger;
        return peticion;
    }
}


///////////////////////////


GEOPISTA.Base.ObjetoAMostrarMientrasSeCargaPeticion = function(nodoPadre){
    var _nodoPadre = nodoPadre;
    var _objetoAMostrarMientrasSeCargaPeticion = null;
    var _funcionVisible;
    var _funcionCargando;
    this.setObjeto = function(parametros){
        //debugger;
        if(parametros.objeto!=null){
            _objetoAMostrarMientrasSeCargaPeticion = parametros.objeto;
            if(parametros.funcionVisible){
                _funcionVisible = parametros.funcionVisible;
            }
            if(parametros.funcionCargando){
                _funcionCargando = parametros.funcionCargando;
            }
            if(_objetoAMostrarMientrasSeCargaPeticion.domNode){
                nodoPadre.appendChild(_objetoAMostrarMientrasSeCargaPeticion.domNode);
            }else{
                nodoPadre.appendChild(_objetoAMostrarMientrasSeCargaPeticion);
            }
        }else{
            alert("Error al introducir un objeto");
        }
    }
    this.setVisible = function(esVisible){
        //debugger;
        if(esVisible==true){
            //_objetoAMostrarMientrasSeCargaPeticion.domNode.style.zIndex="200";
            _nodoPadre.style.visibility = "visible";
            if(_funcionCargando!=null){
                eval(_funcionCargando);
            }    
        }else{
            _nodoPadre.style.visibility = "hidden";
            if(_funcionVisible!=null){
                eval(_funcionVisible);
            }
            //_objetoAMostrarMientrasSeCargaPeticion.domNode.style.zIndex="0";
        }
    }
}