/*
Project: HUMBOLDT GEOPISTA
File: geopistaOperacion.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.
 */
if(!GEOPISTA){
    var GEOPISTA = new Object();
}

if(!GEOPISTA.Operacion){
    GEOPISTA.Operacion = new Object();
    GEOPISTA.Operacion.MOVER_DCHA = 1;
    GEOPISTA.Operacion.MOVER_IZDA = 2;
    GEOPISTA.Operacion.MOVER_ARRIBA = 3;
    GEOPISTA.Operacion.MOVER_ABAJO = 4;
    GEOPISTA.Operacion.TREINTA_POR_CIENTO = 0.3;
    
    GEOPISTA.Operacion.ZOOM = 5;
    GEOPISTA.Operacion.ZOOM_MENOS =6;
    GEOPISTA.Operacion.MANO = 7;
    GEOPISTA.Operacion.RUBBERBAND = 8;
    GEOPISTA.Operacion.REGLA = 9;
    GEOPISTA.Operacion.COORDENADAS = 10;	
    GEOPISTA.Operacion.AYUNTAMIENTO = 11;
    GEOPISTA.Operacion.REFRESCAR = 12;	
    GEOPISTA.Operacion.CAMBIA_TAMANO = 13;
    GEOPISTA.Operacion.IR_A_COORDENADAS = 14;
    
    GEOPISTA.Operacion.CHINCHETA_POIS = 15;
    GEOPISTA.Operacion.CHINCHETA_COORDENADAS = 16;
    GEOPISTA.Operacion.CHINCHETA_CALLE = 17;
    
    GEOPISTA.Operacion.BUSCADOR_VIAS = 18
    GEOPISTA.Operacion.BUSCADOR_POIS = 19;
    
    GEOPISTA.Operacion.GET_FEATURE_INFO = 20;
    
    GEOPISTA.Operacion.PORCENTAJE_ZOOM_MAS = 0.5;
    GEOPISTA.Operacion.PORCENTAJE_ZOOM_MENOS = 2;
}

/*
 *
 */

GEOPISTA.Operacion.Zoom = function(){
    
    this.getBBox = function(bbox, punto, escalado){
        //console.log(escalado);
        var distanciaX = bbox.utmXMax - bbox.utmXMin;
        var distanciaY = bbox.utmYMax - bbox.utmYMin;
        var xmax = punto.x +((distanciaX/2) * escalado);
        var ymax = punto.y +((distanciaY/2) * escalado);
        var xmin = punto.x -((distanciaX/2) * escalado);
        var ymin = punto.y -((distanciaY/2) * escalado);
        
        var bBoxPeticion = new GEOPISTA.Base.BBox(xmin,ymin, xmax, ymax);
        return bBoxPeticion;
    }
}

/*
 *
 */

GEOPISTA.Operacion.Mover = function(){
    
    // el porcentajeDesplazamiento es la cantidad que queremos que se desplace el mapa, por ejemplo
    // si queremos que se mueva un 30% tomar el valor 0.3
    this.getBBox = function(bbox, operacion, porcentajeDesplazamiento){
        var xmin, xmax, ymin, ymax, distancia, desplazamiento;
        switch(operacion){
            // dcha
            case GEOPISTA.Operacion.MOVER_DCHA:
                distancia = bbox.utmXMax - bbox.utmXMin;
                desplazamiento = distancia * porcentajeDesplazamiento;
                xmax = bbox.utmXMax + desplazamiento;
                xmin = bbox.utmXMin + desplazamiento;
                ymax = bbox.utmYMax;
                ymin = bbox.utmYMin;
                break;			
                // izquierda
            case GEOPISTA.Operacion.MOVER_IZDA:
                distancia = bbox.utmXMax - bbox.utmXMin;
                desplazamiento = distancia* porcentajeDesplazamiento;
                xmax = bbox.utmXMax - desplazamiento;
                xmin = bbox.utmXMin  - desplazamiento;
                ymax = bbox.utmYMax;
                ymin = bbox.utmYMin;
                break;	
                // arriba			
            case GEOPISTA.Operacion.MOVER_ARRIBA:
                distancia = bbox.utmYMax - bbox.utmYMin;
                desplazamiento = distancia * porcentajeDesplazamiento;
                xmax = bbox.utmXMax;
                xmin = bbox.utmXMin;
                ymax = bbox.utmYMax+ desplazamiento;
                ymin = bbox.utmYMin+ desplazamiento;
                break;			
                // abajo
            case GEOPISTA.Operacion.MOVER_ABAJO:
                distancia = bbox.utmYMax - bbox.utmYMin;
                desplazamiento = distancia * porcentajeDesplazamiento;
                xmax = bbox.utmXMax;
                xmin = bbox.utmXMin;
                ymax = bbox.utmYMax- desplazamiento;
                ymin = bbox.utmYMin- desplazamiento;
                break;			
                // error, devolvemos por defecto la misma imagen
            default: 
                alert("NO ES VALIDO EL ID:"+operacion);
                xmax = bbox.utmXMax;
                xmin = bbox.utmXMin;
                ymax = bbox.utmYMax;
                ymin = bbox.utmYMin;
                break;
        }
        var bBoxPeticion = new GEOPISTA.Base.BBox(xmin,ymin, xmax, ymax);
        return bBoxPeticion;
    }
}

/*
 *
 */

// en la mano lo que nos interesa saber es el punto donde suelta el raton
GEOPISTA.Operacion.Mano = function(capaMapas, capaOperacion){
    
    var _capaMapas = capaMapas;
    var _xMin = 0;
    var _yMin = 0;
    var _xMax = 0;
    var _yMax = 0;
    
    var _capaPadre = _capaMapas.parentNode;
    
    //this.LIMITE_X_MIN = 0;
    //this.LIMITE_Y_MIN = 0;
    var _leftCapa = parseInt(_capaPadre.style.left);    //_capaMapas
    var _topCapa = parseInt(_capaPadre.style.top);      //_capaMapas
    
    // almacenar�la distancia entre el punto pinchado y el margen top y left de la capa
    var _distanciaX = 0;
    var _distanciaY = 0;
    
    var _capaReceptoraEventos = capaOperacion;
    
    this.setPuntoInicial = function(evt){
        // para saber la distancia entre el raton y el top/left de la capa
        //alert("hemos iniciado el punto"+evt.pageX+" "+ evt.pageY );
        //if((evt.pageX>this.LIMITE_X_MIN)&&(evt.pageY>this.LIMITE_Y_MIN)){
            _xMin = evt.pageX; 
            _yMin = evt.pageY; 
            _distanciaX = evt.pageX;
            _distanciaY = evt.pageY;
            
            //ahora le damos movimiento
            dojo.event.kwConnect({srcObj: _capaReceptoraEventos, srcFunc:"onmousemove", adviceObj:this, adviceFunc:"mover", once:true}); 
        //}
    }
    
    this.mover = function(evt){
        //alert("estamos en movimiento el punto"+evt.pageX+" "+ evt.pageY );
        //var miDebug = dojo.byId("txtUTMY");
        var desplazamientoX = parseInt(evt.pageX - _distanciaX);
        var desplazamientoY = parseInt(evt.pageY - _distanciaY);
        _capaMapas.style.top = desplazamientoY + 'px';
        _capaMapas.style.left = desplazamientoX +'px';
    }
    this.setPuntoFinal = function(evt){
        //if((evt.pageX>this.LIMITE_X_MIN)&&(evt.pageY>this.LIMITE_Y_MIN)){
            // actualizamos el valor de leftCapa y topCapa ya que �tas se han movido
            _leftCapa = parseInt(_capaMapas.style.left);
            _topCapa = parseInt(_capaMapas.style.top);
            _xMax = _distanciaX - _leftCapa;
            _yMax = _distanciaY - _topCapa;
            // desconectamos los eventos
            dojo.event.kwDisconnect({srcObj: _capaReceptoraEventos, srcFunc:"onmousemove", adviceObj:this, adviceFunc:"mover", once:true});   
        //}	
    }
    
    this.getBBox = function (bbox, escala){
        // debugger;
        var xmin, xmax, ymin, ymax;
        var nuevoBBox;
        var desplazamientoX = (_xMax - _xMin);
        var desplazamientoY = (-_yMax + _yMin);	
        //alert("despX de la mano:" + mano.getDesplazamientoX() + " y:" + mano.getDesplazamientoY());
        var xMinNuevo = bbox.utmXMin + (desplazamientoX/escala);
        var yMinNuevo = bbox.utmYMin + (desplazamientoY/escala);
        var xMaxNuevo = bbox.utmXMax + (desplazamientoX/escala);
        var yMaxNuevo = bbox.utmYMax + (desplazamientoY/escala);
        
        var nuevoBBox = new GEOPISTA.Base.BBox(xMinNuevo, yMinNuevo, xMaxNuevo, yMaxNuevo);
        return nuevoBBox;
    }
}

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

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

GEOPISTA.Operacion.Regla = function(){
    var puntos = [];
    var ultimaDistancia = 0;
    var distanciaTotal = 0;
    
    this.addPunto= function(pto){
        var ultimoPto = null;
        if(puntos.length > 0){
            ultimoPto = puntos.slice(-1);	// devuelve el ultimo punto
            var x = Math.abs(pto.getX() - ultimoPto.getX());
            var y = Math.abs(pto.getY() - ultimoPto.getY());
            // pitagoras, h^2 = x^2 + y^2 
            //ultimaDistancia = Math.sqrt((Math.abs(x)*Math.abs(x)) + (Math.abs(y)*Math.abs(y)));
            ultimaDistancia = Math.sqrt((x*x) + (y*y));
            distanciaTotal += ultimaDistancia;
        }
        puntos.push(pto);
    }
    this.getUltimaDistancia = function (){
        return ultimaDistancia;
    }
    this.getDistanciaTotal = function (){
        return distanciaTotal;
    }
    
    this.deletePunto = function(){
        // si tengo algun punto en la regla borramos el ltimo
        if(puntos.length>0){
            var ptoABorrar = puntos.pop();
            // ahora hay que actualizar las distancias, para ello veremos 
            // si haba al principio 2 puntos (ahora tendr un punto por lo que la distancia es 0)
            // o si haba al principio 3 o ms puntos (sacaremos el punto anterior para restar la distancia)
            if(puntos.lenght==1){
                ultimaDistancia = 0;
                distanciaTotal = 0;
                // tendremos que actualizar la distancia total (para ello basta con sacar el penltimo punto)
                // pero tambin habr que actualizar la ultima distancia (para ello hay que sacar el antepenltimo punto)
            }else{
                // sacamos el penltimo para obtener la distancia total
                var penultimo = puntos.pop();
                var x = Math.abs(ptoABorrar.getX() - penultimo.getX());
                var y = Math.abs(ptoABorrar.getY() - penultimo.getY());
                // hacemos el absoluto no vaya a ser que a distancias muy pequeas javascript 
                // por consecutivos errores de clculos nos devuelva una distancia negativa, en
                // teora no hara falta hacer el absolute y con poner el -= valdra.
                distanciaTotal = Math.abs((distanciaTotal)- Math.sqrt((x*x) + (y*y)));
                // hay que sacar el antepenultimo para obtener la ultima distancia
                var antePenultimo = puntos.pop();
                x = Math.abs(antePenultimo.getX() - penultimo.getX());
                y = Math.abs(antePenultimo.getY() - penultimo.getY());
                ultimaDistancia = Math.sqrt((x*x) + (y*y));
                // volvemos a dejar los puntos como estaban
                puntos.push(antePenultimo);
                puntos.push(penultimo);
            }
            
        }
    }
}

//////////////////////////////////////////////////////////////////
// RUBBERBAND
//////////////////////////////////////////////////////////////////

// rubberband es el efecto de pinchar en un punto y arrastrar el ratn hasta que
// soltamos. Tomaremos pues el punto donde pincha (puntoMin) y el punto donde 
// suelta (puntoMax). Para ello tenemos dos mtodos para inicializar estos puntos
// y el mtodo de obtener el bbox asociado


/*
 * Por lo general el color del rubberband es  "#AABBCC", y su transparencia 0.6 (Transparencia va de 0 a 1)
 */
GEOPISTA.Operacion.Rubberband = function(capaMapas, capaOperacion, colorRubberband, transparencia){
    var _puntoMin = new GEOPISTA.Base.Punto(); 
    var _puntoMax = new GEOPISTA.Base.Punto();
    //var relacionXdividoY;
    var _capaMapas = capaMapas;
    var _capaOperacion = capaOperacion;    
    
    var _nodoRubberband;
    var _colorRubber = colorRubberband;
    var _transparencia = transparencia;
    
    var _styleNodoRubberband;
    this.getNodoRubberband = function(){
        return _nodoRubberband;
    }
    
    this.setPuntoMinimo = function(evt){
        if(_nodoRubberband!=null){
            quitarRubberband();
        }
        //Pasos necesarios para inicializar el rubberband
        _nodoRubberband = document.createElement("div");
        _nodoRubberband.setAttribute('unselectable', 'on');
        
        _styleNodoRubberband = _nodoRubberband.style;
        _styleNodoRubberband.position = "absolute";
        _styleNodoRubberband.backgroundColor = _colorRubber;           
        _styleNodoRubberband.zIndex = 200;
        _styleNodoRubberband.width = 0 + 'px';
        _styleNodoRubberband.height = 0 + 'px';
        
        dojo.html.setOpacity(_nodoRubberband,_transparencia);
        document.body.appendChild(_nodoRubberband);
        
        // tras inicializar el rubberband, tomamos los puntos
        
        _puntoMin.x = evt.pageX;	
        _puntoMin.y = evt.pageY;
        _styleNodoRubberband.left = _puntoMin.x+'px';
        _styleNodoRubberband.top = _puntoMin.y+'px';
        
        dojo.event.kwConnect({srcObj:_capaOperacion, srcFunc:"onmousemove",adviceObj:this, adviceFunc:"mueveRubberband", once:true});
        // por si se queda el ratón encima de la propia capa del rubber
        // esto pasa cdo en vez de hacer el rubber de izquierda hacia la derecha y/o arriba hacia abajo lo hacemos al reves
        
    }
    
    this.mueveRubberband = function(evt){
        if(_nodoRubberband!=null){
            dojo.event.kwConnect({srcObj: _capaOperacion,srcFunc:"onmouseup" , adviceObj: this, adviceFunc: "setPuntoMaximo", once:true});
            // si soltamos el bot� del rat� encima del rubberband
            dojo.event.kwConnect({srcObj: _nodoRubberband, srcFunc:"onmouseup" , adviceObj: this, adviceFunc: "setPuntoMaximo", once:true});
            var widthRubber = _puntoMin.x-evt.pageX;
            var heightRubber = _puntoMin.y-evt.pageY;
            _styleNodoRubberband.width = Math.abs(widthRubber) + 'px';
            _styleNodoRubberband.height = Math.abs(heightRubber) + 'px';
            // si el punto actual del ratón está más a la izquierda/abajo
            // es que tiene valor inferior a los iniciales, por lo que el
            // resultado de la resta es positiva
            if((widthRubber)>0){
                _styleNodoRubberband.left = evt.pageX +'px';
            }
            if((heightRubber)>0){
                _styleNodoRubberband.top = evt.pageY +'px';
            }
        }
    }
    
    this.setPuntoMaximo = function(evt){
        if(_nodoRubberband!=null){
            _puntoMax.x = evt.pageX;	
            _puntoMax.y = evt.pageY;
            preparaPuntosParaCalculos();
        }
        // desconectamos el evento onmousemove y el onmouseup
        dojo.event.kwDisconnect({srcObj:_capaOperacion, srcFunc:"onmousemove",adviceObj:this, adviceFunc:"mueveRubberband", once:true});
        // por si se queda el ratón encima de la propia capa del rubber
        // esto pasa cdo en vez de hacer el rubber de izquierda hacia la derecha y/o arriba hacia abajo lo hacemos al reves
        dojo.event.kwDisconnect({srcObj: _capaOperacion,srcFunc:"onmouseup" , adviceObj: this, adviceFunc: "setPuntoMaximo", once:true});
        // si soltamos el bot� del rat� encima del rubberband
        dojo.event.kwDisconnect({srcObj: _nodoRubberband, srcFunc:"onmouseup" , adviceObj: this, adviceFunc: "setPuntoMaximo", once:true});
        quitarRubberband();
    }
    
    this.getBBox = function(bboxActual, relacionXdividoY, relacionLongitudPixelesMapaConPixelesImagen){
        var bBoxPeticion = null;
        var xMinMapa, xMaxMapa, yMinMapa, yMaxMapa, centro, distancia;
        // las variables para el nuevo valor del bbox
        var xmin, ymin, xmax, ymax;
        // Hay que convertir los puntos en coordenadas en p�eles a coordenadas en metros
        
        
        var xMinMapa = bboxActual.utmXMin + _puntoMin.x/relacionLongitudPixelesMapaConPixelesImagen;
        var yMinMapa = bboxActual.utmYMax - _puntoMin.y/relacionLongitudPixelesMapaConPixelesImagen;
        
        var xMaxMapa = bboxActual.utmXMin + _puntoMax.x/relacionLongitudPixelesMapaConPixelesImagen;
        var yMaxMapa = bboxActual.utmYMax - _puntoMax.y/relacionLongitudPixelesMapaConPixelesImagen;
        
        // si la distancia X es mayor que la Y entonces tomamos X como referencia
        var distanciaX = xMaxMapa - xMinMapa;
        var distanciaY = yMaxMapa - yMinMapa;
        if((distanciaX >1)&&(distanciaY>1)){
            if(distanciaX > distanciaY){
                xmin = xMinMapa;
                xmax = xMaxMapa;
                // calculamos el centro de las coordenadas y, para ello tengo que
                // saber el valor de la coordenada minima más la mitad de la distancia pasada
                // como la distancia pasada no guarda relacion (puede ser o muy estrecha o 
                // muy ancha) tenemos que usar la relación que tenemos del monitor, que viene
                // reflejado por la variable relacionXdivididoY 
                centro = ((yMaxMapa-yMinMapa)/2)+ yMinMapa;
                ymin = centro - ((distanciaX)/relacionXdividoY)/2;
                ymax = centro + ((distanciaX)/relacionXdividoY)/2;
                //console.log("Rubberband.getBBox: DX>DY: centro y:"+centro+" xmin:"+xmin+" ymin:" + ymin + " xmax:"+xmax+" ymax:"+ymax);
                //ymax = centro + (bboxPasado.getDistanciaX()/relacionXdividoY);
            }else{
                ymin = yMinMapa;
                ymax = yMaxMapa;
                // calculamos el centro de las coordenadas x, para ello tengo que
                // saber el valor de la coordenada minima más la mitad de la distancia pasada
                // como la distancia pasada no guarda relacion (puede ser o muy estrecha o 
                // muy ancha) tenemos que usar la relación que tenemos del monitor, que viene
                // reflejado por la variable relacionXdivididoY
                //centro = puntoMin.getX()+(bboxPasado.getDistanciaX()/2);
                //centro = (puntoMin.getX()+puntoMax.getX())/2;
                centro = ((xMaxMapa-xMinMapa)/2)+ xMinMapa;
                xmin = centro - ((distanciaY)*relacionXdividoY)/2;
                xmax = centro + ((distanciaY)*relacionXdividoY)/2;
                //console.log("Rubberband.getBBox: DY>DX: centro x:"+centro+" xmin:"+xmin+" ymin:" + ymin + " xmax:"+xmax+" ymax:"+ymax);
            }
            bBoxPeticion = new GEOPISTA.Base.BBox(xmin,ymin,xmax,ymax);
        }
        return bBoxPeticion;
    }
    
    // Se ordenar� los puntos en funci� de sus coordenadas y se le restar� el desplazamiento a cada punto.
    preparaPuntosParaCalculos = function(){
        var tempX = 0;
        var tempY = 0;
        if(_puntoMin.x > _puntoMax.x){
            tempX = _puntoMin.x;
            _puntoMin.x = _puntoMax.x;
            _puntoMax.x = tempX;
        }
        // porque van al reves las coordenadas del visor con las UTM.
        // Las UTM crecen hacia arriba y las de la página html crece hacia abajo
        if(_puntoMin.y < _puntoMax.y){
            tempY = _puntoMin.y;
            _puntoMin.y = _puntoMax.y;
            _puntoMax.y = tempY;
        }
        // Como las capas de los mapas estar� desplazadas unos p�eles top y left
        // tenemos que descontarlos para realizar las operaciones.
        var padre = _capaMapas.parentNode;
        var topPadre = parseInt(padre.style.top);
        var leftPadre = parseInt(padre.style.left);
        _puntoMin.x -= leftPadre;
        _puntoMax.x -= leftPadre;
        _puntoMin.y -= topPadre;
        _puntoMax.y -= topPadre;
    }
    
    quitarRubberband = function(){
        document.body.removeChild(_nodoRubberband);
        _nodoRubberband = null;
    }
}

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


GEOPISTA.Operacion.IrAlAyuntamiento = function(){
    this.getBBox = function(utmX, utmY, escala, capaPadreMapas){
        var capaPadreMapas = dojo.byId(capaPadreMapas);
        var widthCapaPadreMapas = parseInt(capaPadreMapas.style.width);
        var heightCapaPadreMapas = parseInt(capaPadreMapas.style.height);
        
        var cmWidthCapaPadreMapas = widthCapaPadreMapas / PIXELES_POR_CENTIMETRO ;
        var cmHeightCapaPadreMapas = heightCapaPadreMapas / PIXELES_POR_CENTIMETRO ;
        
        var distanciaX = (cmWidthCapaPadreMapas * escala)/100;
        var distanciaY = (cmHeightCapaPadreMapas * escala)/100;
        
        // ahora generamos el bbox
        var xMin = utmX - distanciaX/2;
        var yMin = utmY - distanciaY/2;
        var xMax = utmX + distanciaX/2;
        var yMax = utmY + distanciaY/2;
        
        var bbox = new GEOPISTA.Base.BBox(xMin, yMin, xMax, yMax);
        
        return bbox;
    }
}

GEOPISTA.Operacion.Chincheta = function(tipoChincheta){
    var _tipo = tipoChincheta;
    this.utmX;
    this.utmY;
    this.texto;
    this.capa = document.createElement("div");
    var _urlImagen = "";
    switch(tipoChincheta){
        case GEOPISTA.Operacion.CHINCHETA_CALLE:
            _urlImagen = "img/pushpin_blue.gif";
            break;
        case GEOPISTA.Operacion.CHINCHETA_COORDENADAS:
            _urlImagen = "img/pushpin_green.gif";
            break;
        case GEOPISTA.Operacion.CHINCHETA_POIS:
            _urlImagen = "img/pushpin_red.gif";
            break;
    }
    //capa.src = urlImagen;
    this.capa.style.backgroundImage='url('+_urlImagen+')';
    this.capa.style.visibility = "hidden";
    this.capa.style.width = "55px";
    this.capa.style.height = "55px";
    //capa.style.backgroundRepeat="no-repeat";
    this.capa.style.zIndex=20;
    this.capa.style.position = "absolute";
    
    this.capa.style.top = "0px";
    this.capa.style.left = "0px";
}

GEOPISTA.Operacion.IrACoordenadas = function(capaChinchetas){
    var _chinchetas = [];
    var _irAUTMX = null;
    var _irAUTMY = null;
    //var escala = null;
    //var relacionXdividoY = null;
    var _capaChinchetas = capaChinchetas;
    //var tamanoMapaX = null;
    
    addChincheta = function(chincheta){
        // si fueran muchas se podrían ordenar en función del eje X o Y
        if(chincheta instanceof GEOPISTA.Operacion.Chincheta){
            _irAUTMX = chincheta.utmX;
            _irAUTMY = chincheta.utmY;
            // maximo chinchetas a 3
            if(_chinchetas.length==GEOPISTA.Operacion.CHINCHETAS_MAXIMAS){
                // eliminamos la ultima
                var chinchetaABorrar = _chinchetas[0];
                // vamos a la posici� 0 y eliminamos 1 elemento
                _chinchetas.splice(0,1);
                _capaChinchetas.removeChild(chinchetaABorrar.capa);
                chinchetaABorrar = null;
            }
            _chinchetas.push(chincheta);
            _capaChinchetas.appendChild(chincheta.capa);
            return true;
        }else{
            return false;
        }
    }
    
    this.getBBox = function(relacionXdivididoY, escala, tamanoMapaX, chincheta){
        //debugger;
        var bbox = null;
        if(addChincheta(chincheta)){
            //var distanciaX = _irAUTMX*(escala)*relacionXdividoY;
            //var distanciaY = _irAUTMY*(escala)/relacionXdividoY;
            var tamanoMapaY = tamanoMapaX / relacionXdivididoY;
            
            var distanciaX = tamanoMapaX/escala;
            var distanciaY = tamanoMapaY/escala;
            
            var xmin = _irAUTMX-distanciaX/2;
            var xmax = _irAUTMX+distanciaX/2;
            var ymin = _irAUTMY-distanciaY/2;
            var ymax = _irAUTMY+distanciaY/2;
            
            bbox = new GEOPISTA.Base.BBox(xmin,ymin, xmax, ymax);
        }else{
            //alert("GEOPISTA.Operacion.IrACoordenadas.addChincheta: chincheta no es instancia de GEOPISTA.Operacion.Chincheta: su valor es:"+chincheta);
        }
        return bbox;
    }
    
    this.recolocaChinchetas = function(bboxActual, escala){
        //debugger;
        if(bboxActual instanceof GEOPISTA.Base.BBox){
            for(var i=0; i<_chinchetas.length; i++){
                var capaDeLaChincheta = _chinchetas[i].capa;
                if(estaDentro(bboxActual, _chinchetas[i])){
                    // posicionamos la bandera
                    posicionaBandera(bboxActual,_chinchetas[i], escala);
                    capaDeLaChincheta.style.visibility="visible";
                }else{
                    capaDeLaChincheta.style.visibility="hidden";
                }
            }
        }else{
            alert("GEOPISTA.Operacion.IrACoordenadas.recolocaImagen: el bboxActual no es una instancia de GEOPISTA.Base.BBox: "+bboxActual);
        }
    }
    
    estaDentro = function(bbox, chincheta){
        var utmX = chincheta.utmX;
        var utmY = chincheta.utmY;
        if((utmX>bbox.utmXMin)&&
        (utmY>bbox.utmYMin)&&
        (utmX<bbox.utmXMax)&&
        (utmY<bbox.utmYMax)){
            return true;
        }
        return false;
    }
    posicionaBandera = function(bbox,chincheta, escala){
        //debugger;
        var utmX = chincheta.utmX;
        var utmY = chincheta.utmY;
        var tmpXSinUTM = utmX - bbox.utmXMin;
        var tmpYSinUTM = bbox.utmYMax-utmY;//utmY - bbox.getCoordenada(GEOPISTA.Base.BBox.UTMYMIN);
        var estiloCapaChincheta = chincheta.capa.style;
        // ahora hay que aplicar la escala
        //////////////////////////////////////////////////////////////////////////////////////////////
        var posicionX = (tmpXSinUTM*escala)-25;		// 16 es el ancho de la bandera
        var posicionY = (tmpYSinUTM*escala)-30;		// 16 es el alto de la bandera
        ///////////////////////////////////////////////////////////////////////////////////////////////
        estiloCapaChincheta.top = posicionY + "px";
        estiloCapaChincheta.left = posicionX + "px";
    }
}



/*
 * GestorOperaciones
 */

GEOPISTA.Operacion.GestorOperaciones = function(modeloCargaImagenesPeticiones){
    var _modeloCargaImagenesPeticiones = modeloCargaImagenesPeticiones;
    var _capaOperacionMapa = modeloCargaImagenesPeticiones.getCapaOperacion(true);
    
    // _capaMapas es la capa padre de la que cuelgan todas las peticiones de los mapas.
    // se usar�para la mano
    var _capaMapas = _modeloCargaImagenesPeticiones.getCapaMapas(true);
    //var _capaOperacionGuia = modeloCargaImagenesPeticiones.getCapaOperacion(false);
    var _idOperacion = -1;
    var _operacion = null;
    
    // los eventos 
    dojo.event.kwConnect({srcObj: _capaOperacionMapa, srcFunc:"onclick" , adviceObj:this, adviceFunc: "calculaNuevoBBox", once:true});
    
    var _nodoRubberband = null;
    var _irACoordenadas = new GEOPISTA.Operacion.IrACoordenadas(_capaMapas);
    
    var _capasYEstilosSeleccionados = null;
    
    var _capaFeatureInfo = null;
    var _camposFeatureInfo = null;
    
    var _that = this;
    
    this.init = function(bboxPeticion){
        _modeloCargaImagenesPeticiones.borrarCapasEstilos(true);
        _realizaPeticion(bboxPeticion);
    }
    
    this.setOperacion = function(idOperacion){
        if(idOperacion!=_idOperacion){
            _desconectarEventos();
            switch(idOperacion){
                case GEOPISTA.Operacion.ZOOM_MENOS:
                    _operacion = new GEOPISTA.Operacion.Zoom();
                    _idOperacion = GEOPISTA.Operacion.ZOOM_MENOS;
                    dojo.event.kwConnect({srcObj: _capaOperacionMapa, srcFunc:"onclick" , adviceObj:_that, adviceFunc: "calculaNuevoBBox", once:true});
                    break;	
                case GEOPISTA.Operacion.ZOOM:
                    _operacion = new GEOPISTA.Operacion.Zoom();
                    _idOperacion = GEOPISTA.Operacion.ZOOM;
                    dojo.event.kwConnect({srcObj: _capaOperacionMapa, srcFunc:"onclick" , adviceObj:_that, adviceFunc: "calculaNuevoBBox", once:true});
                    break;
                case GEOPISTA.Operacion.MANO:
                    _operacion = new GEOPISTA.Operacion.Mano(_capaMapas, _capaOperacionMapa);
                    _idOperacion = GEOPISTA.Operacion.MANO;
                    
                    dojo.event.kwConnect({srcObj: _capaOperacionMapa,srcFunc:"onmousedown" ,adviceObj: _operacion, adviceFunc: "setPuntoInicial", once:true});
                    dojo.event.kwConnect({srcObj: _capaOperacionMapa,srcFunc:"onmouseup" ,adviceObj: _operacion, adviceFunc: "setPuntoFinal", once:true});
                    dojo.event.kwConnect({srcObj: _operacion,srcFunc:"setPuntoFinal", adviceObj:_that, adviceFunc: "calculaNuevoBBox", once:true});	
                    _capaOperacionMapa.style.cursor="Move";
                    break;
                case GEOPISTA.Operacion.RUBBERBAND:
                    _operacion = new GEOPISTA.Operacion.Rubberband(_capaMapas, _capaOperacionMapa, GEOPISTA.Operacion.COLOR_RUBBERBAND, GEOPISTA.Operacion.OPACIDAD_RUBBERBAND);
                    _idOperacion = GEOPISTA.Operacion.RUBBERBAND;
                    _capaOperacionMapa.style.cursor="crosshair";
                    // _nodoRubberband
                    
                    dojo.event.kwConnect({srcObj: _capaOperacionMapa,srcFunc:"onmousedown" ,adviceObj: _operacion, adviceFunc: "setPuntoMinimo", once:true});
                    // onmouseup se pone dentro del c�igo del rubberband
                    //dojo.event.kwConnect({srcObj: _capaOperacionMapa,srcFunc:"onmouseup" , adviceObj: _operacion, adviceFunc: "setPuntoMaximo", once:true});
                    dojo.event.kwConnect({srcObj: _operacion,srcFunc:"setPuntoMaximo" , adviceObj: _that, adviceFunc: "calculaNuevoBBox", once:true});              
                    break;
                case GEOPISTA.Operacion.REGLA:
                    _operacion = new GEOPISTA.Operacion.Regla();
                    _idOperacion = GEOPISTA.Operacion.REGLA;
                    break;
                case GEOPISTA.Operacion.MOVER_DCHA:
                    _operacion = new GEOPISTA.Operacion.Mover();
                    _idOperacion = GEOPISTA.Operacion.MOVER_DCHA;
                    this.calculaNuevoBBox(null);
                    break;
                case GEOPISTA.Operacion.MOVER_IZDA:
                    _operacion = new GEOPISTA.Operacion.Mover();
                    _idOperacion = GEOPISTA.Operacion.MOVER_IZDA;
                    this.calculaNuevoBBox(null);
                    break;
                case GEOPISTA.Operacion.MOVER_ARRIBA:
                    _operacion = new GEOPISTA.Operacion.Mover();
                    _idOperacion = GEOPISTA.Operacion.MOVER_ARRIBA;
                    this.calculaNuevoBBox(null);
                    break;
                case GEOPISTA.Operacion.MOVER_ABAJO:
                    _operacion = new GEOPISTA.Operacion.Mover();
                    _idOperacion = GEOPISTA.Operacion.MOVER_ABAJO;
                    this.calculaNuevoBBox(null);
                    break;
                case GEOPISTA.Operacion.AYUNTAMIENTO:
                    _operacion = new GEOPISTA.Operacion.IrAlAyuntamiento();
                    _idOperacion = GEOPISTA.Operacion.AYUNTAMIENTO;
                    this.calculaNuevoBBox(null);
                    break;
                case GEOPISTA.Operacion.REFRESCAR:
                    _idOperacion = GEOPISTA.Operacion.REFRESCAR;
                    this.calculaNuevoBBox(null);
                    break;
                case GEOPISTA.Operacion.IR_A_COORDENADAS:
                    /*if(_irACoordenadas==null){
                        _irACoordenadas = new GEOPISTA.Operacion.IrACoordenadas(_capaOperacionMapa);
                    }*/
                    _idOperacion = GEOPISTA.Operacion.IR_A_COORDENADAS;
                    //this.calculaNuevoBBox(null);
                    break;
                case GEOPISTA.Operacion.GET_FEATURE_INFO:
                    _idOperacion = GEOPISTA.Operacion.GET_FEATURE_INFO;
                    _operacion = new GEOPISTA.Operacion.GetFeatureInfo(document.body);
                    // habra que inicializar la operacion con los campos antes de 
                    // hacer la peticion
                    
                    dojo.event.kwConnect({srcObj: _capaOperacionMapa,srcFunc:"onmousedown" ,adviceObj: _that, adviceFunc: "getFeatureInfo", once:true});
                    break;
                default:
                    _idOperacion = -1;
                    break;
            }
        }else{
            // si la operacion solicitada es la misma que la que ten�mos, entonces solo desconectamos los eventos.
            // esto sucede cuando ten�mos por ejemplo el zoom mas y volvemos a pinchar en el zoom mas, el resultado
            // es que no tenemos ninguna operaci� a realizar, NO que podamos hacer zoom mas.
            _desconectarEventos();
        } 
    }
    
    this.calculaNuevoBBox = function(evt){
        //debugger;
        var bboxActual = _modeloCargaImagenesPeticiones.getBBox(true);
        var bboxPeticion = null;
        
        var puntoActual = null;
        var puntoMaximo = null;
        //var porcentajeZoom = null;
        //var relacionXdividoY = null;
        //var escalaActual = null;
        // ahora en funci� de la operacion actual cogeremos unos par�etros u otros
        switch(_idOperacion){
            case GEOPISTA.Operacion.ZOOM_MENOS:
                puntoActual = _modeloCargaImagenesPeticiones.getPuntoActual(evt, true);
                bboxPeticion = _operacion.getBBox(bboxActual,puntoActual,GEOPISTA.Operacion.PORCENTAJE_ZOOM_MENOS);
                break;	
            case GEOPISTA.Operacion.ZOOM:
                puntoActual = _modeloCargaImagenesPeticiones.getPuntoActual(evt, true);
                bboxPeticion = _operacion.getBBox(bboxActual,puntoActual,GEOPISTA.Operacion.PORCENTAJE_ZOOM_MAS);
                break;
            case GEOPISTA.Operacion.MANO:
                //escalaActual = _modeloCargaImagenesPeticiones.getEscala(true);
                var relacion = _modeloCargaImagenesPeticiones.getRelacionLongitudPixelesMapaConPixelesImagen(true);
                bboxPeticion = _operacion.getBBox(bboxActual,relacion);
                break;
            case GEOPISTA.Operacion.RUBBERBAND:
                //relacion puesta a mano, borrar
                //var relacionXDivididoY = 792/540;
                //debugger;
                bboxPeticion = _operacion.getBBox(bboxActual,_modeloCargaImagenesPeticiones.getRelacionXDivididoY(true), 
                _modeloCargaImagenesPeticiones.getRelacionLongitudPixelesMapaConPixelesImagen(true));
                break;
            case GEOPISTA.Operacion.REGLA:
                
                break;
            case GEOPISTA.Operacion.MOVER_DCHA:
            case GEOPISTA.Operacion.MOVER_IZDA:
            case GEOPISTA.Operacion.MOVER_ARRIBA:
            case GEOPISTA.Operacion.MOVER_ABAJO:
                bboxPeticion = _operacion.getBBox(bboxActual, _idOperacion, GEOPISTA.Operacion.TREINTA_POR_CIENTO);
                _idOperacion = -1;
                break;
            case GEOPISTA.Operacion.AYUNTAMIENTO:
                _idOperacion = -1;
                //debugger;
                var ayuntamiento = _modeloCargaImagenesPeticiones.ayuntamiento;
                //(utmX, utmY, escala, capaPadreMapas){
                bboxPeticion = _operacion.getBBox(ayuntamiento.x,ayuntamiento.y, 
                GEOPISTA.Base.AYUNTAMIENTO_ESCALA_INICIAL, _capaMapas);
                break;
            case GEOPISTA.Operacion.REFRESCAR:
                _idOperacion = -1;
                bboxPeticion = bboxActual;
                break;
            case GEOPISTA.Operacion.IR_A_COORDENADAS:
                bboxPeticion = _irACoordenadas.getBBox(_modeloCargaImagenesPeticiones.getRelacionXDivididoY(true), 
                _modeloCargaImagenesPeticiones.getRelacionLongitudPixelesMapaConPixelesImagen(true), 
                parseInt(_capaOperacionMapa.style.width), evt); 
                _idOperacion = -1;
                break;
            case  GEOPISTA.Operacion.GET_FEATURE_INFO:
                
                break;
            default:
                _idOperacion = -1;
                break;
        }
        
        // si el bboxPeticion es valido
        if((bboxPeticion!=null)&&
        (!isNaN(bboxPeticion.utmXMin))&&
        (!isNaN(bboxPeticion.utmXMax))&&
        (!isNaN(bboxPeticion.utmYMin))&&
        (!isNaN(bboxPeticion.utmYMax))&&
        (bboxPeticion.utmXMin!=bboxPeticion.utmXMax)&&
        (bboxPeticion.utmYMin!=bboxPeticion.utmYMax)
        ){
            //debugger;
            _modeloCargaImagenesPeticiones.borrarCapasEstilos(true);
            _realizaPeticion(bboxPeticion);
            bboxPeticion=null;
        }
    }
    
    this.cancelaOperacion = function(){
        _desconectarEventos();
    }
    /*
     * La vista le dir�qu�capas han sido seleccionadas.
     */
    this.setCapasYEstilosSeleccionados = function(capasYEstilosSeleccionados){
        //        debugger;
        _capasYEstilosSeleccionados = capasYEstilosSeleccionados;
    }
    
    this.setCapaYCamposFeatureInfo = function(capa, campos){
        _capaFeatureInfo = capa;
        _camposFeatureInfo = campos;
    }
    
    this.irACoordenadas = function(chincheta){
        //debugger;
        this.calculaNuevoBBox(chincheta);
    }
    
    //el evt tiene las coordenadas X,Y
    this.getFeatureInfo = function(evt){
        if((_capaFeatureInfo!=null)&&(_camposFeatureInfo!=null)){ 
            var peticion = _modeloCargaImagenesPeticiones.getFeatureInfo(
            _capaFeatureInfo, _camposFeatureInfo, evt.layerX, evt.layerY);
            // mostrara un panel flotante con la informacion
            if(_operacion instanceof GEOPISTA.Operacion.GetFeatureInfo){
                _operacion.muestraInformacion(peticion, _capaFeatureInfo, _camposFeatureInfo);
            }
            _capaFeatureInfo = null;
            _camposFeatureInfo = null;
        }else{
            //alert("solo para depuracion: gestorOperaciones.getFeatureInfo _capaFeatureInfo:"+_capaFeatureInfo+ " _camposFeatureInfo:"+_camposFeatureInfo);
        }     
    }
    /*
     * Esta unido al mostrarMapas del modelo. Lo que hace es reposicionar las chinchetas en funci� del nuevo bbox que se muestra al usuario
     */
    this.recolocaChinchetas = function(evt){
        if(_irACoordenadas!=null){
            _irACoordenadas.recolocaChinchetas(modeloCargaImagenesPeticiones.getBBox(true), _modeloCargaImagenesPeticiones.getRelacionLongitudPixelesMapaConPixelesImagen(true));
        }
    }
    
    this.isTodosMapasCargados = function(aPeticiones){
        return(_modeloCargaImagenesPeticiones.isTodosMapasCargados(aPeticiones));
    }
    
    //
    _realizaPeticion = function(bboxPeticion){
        // habr�que cargar capas y estilos
        //        debugger;
        _modeloCargaImagenesPeticiones.setBBox(bboxPeticion,true);
        //_modeloCargaImagenesPeticiones.borrarCapasEstilos(true);
        if(_capasYEstilosSeleccionados!=null){
            for(var i=0; i<_capasYEstilosSeleccionados.length; i++){
                _modeloCargaImagenesPeticiones.addCapaEstilo(_capasYEstilosSeleccionados[i].capa,
                _capasYEstilosSeleccionados[i].estilo,
                _capasYEstilosSeleccionados[i].idPeticion, true);
            }
            // tras saber qu�capas y estilos, los eliminamos
            _capasYEstilosSeleccionados = null;
        }
        _modeloCargaImagenesPeticiones.cargaMapas(true);
        
    }
    
    /*
     * si conectar = true: hace el kwConnect, si conectar=false hace kwDisconnect y adem�: _idOperacion=-1; _operacion=null;
     */
    _desconectarEventos = function(){
        switch(_idOperacion){
            case GEOPISTA.Operacion.ZOOM_MENOS:
                dojo.event.kwDisconnect({srcObj: _capaOperacionMapa, srcFunc:"onclick" , adviceObj:_that, adviceFunc: "calculaNuevoBBox", once:true});
                break;	
            case GEOPISTA.Operacion.ZOOM:
                dojo.event.kwDisconnect({srcObj: _capaOperacionMapa, srcFunc:"onclick" , adviceObj:_that, adviceFunc: "calculaNuevoBBox", once:true});
                break;
            case GEOPISTA.Operacion.MANO:
                
                dojo.event.kwDisconnect({srcObj: _capaOperacionMapa,srcFunc:"onmousedown" ,adviceObj: _operacion, adviceFunc: "setPuntoInicial", once:true});
                dojo.event.kwDisconnect({srcObj: _capaOperacionMapa,srcFunc:"onmouseup" ,adviceObj: _operacion, adviceFunc: "setPuntoFinal", once:true});
                dojo.event.kwDisconnect({srcObj: _operacion,srcFunc:"setPuntoFinal", adviceObj:_that, adviceFunc: "calculaNuevoBBox", once:true});
                dojo.event.kwDisconnect({srcObj: _capaOperacionMapa, srcFunc:"onmousemove", adviceObj:_operacion, adviceFunc:"mover", once:true}); 
                
                // dejamos las capas en su sitio
                _capaOperacionMapa.style.top = "0px";
                _capaOperacionMapa.style.left = "0px";
                _capaMapas.style.top = "0px";
                _capaMapas.style.left = "0px";
                break;
            case GEOPISTA.Operacion.RUBBERBAND:
                // comprobamos si tenemos el nodoRubberband
                var nodoRubberband = _operacion.getNodoRubberband();
                if(nodoRubberband!=null){
                    document.body.removeChild(nodoRubberband);
                    nodoRubberband = null;
                }
                dojo.event.kwDisconnect({srcObj: _capaOperacionMapa,srcFunc:"onmousedown" ,adviceObj: _operacion, adviceFunc: "setPuntoMinimo", once:true});
                dojo.event.kwDisconnect({srcObj: _capaOperacionMapa,srcFunc:"onmouseup" , adviceObj: _operacion, adviceFunc: "setPuntoMaximo", once:true});
                dojo.event.kwDisconnect({srcObj: nodoRubberband,srcFunc:"onmouseup" , adviceObj: _operacion, adviceFunc: "setPuntoMaximo", once:true});
                
                //dojo.event.kwDisconnect({srcObj: rubberband , srcFunc:"onmouseup", adviceObj:rubberband ,adviceFunc:"setPuntoFinal", once:true});
                dojo.event.kwDisconnect({srcObj: _operacion,srcFunc:"setPuntoMaximo" , adviceObj:_that, adviceFunc: "calculaNuevoBBox", once:true});
                break;
            case GEOPISTA.Operacion.REGLA:
                
                break;
            case GEOPISTA.Operacion.GET_FEATURE_INFO:
                dojo.event.kwDisconnect({srcObj: _capaOperacionMapa,srcFunc:"onmousedown" ,adviceObj: _that, adviceFunc: "getFeatureInfo", once:true});
                if(_operacion instanceof GEOPISTA.Operacion.GetFeatureInfo){
                    _operacion.hide();
                    _operacion.destroy();
                }
                break;    
                
            default:
                
                break;
        }
        _operacion = null;
        _idOperacion = -1;
        // dejar el estilo del cursor como estaba
        _capaOperacionMapa.style.cursor="Default";
    }
}


// 
GEOPISTA.Operacion.GetFeatureInfo = function(divCapaPadre){
    var _capaPadre = divCapaPadre;
    var _capaFloatingPane = document.createElement("div");
    var _tabla = document.createElement("table");
    var _widgetFloatingPane = null;
    
    var _capa = null;
    var _campos = null;
    
    _capaFloatingPane.style.position="absolute";
    _capaFloatingPane.style.width="300px";
    _capaFloatingPane.style.height="300px";
    
    _capaFloatingPane.style.visibility = "hidden";
    
    _capaFloatingPane.style.top=((parseInt(dojo.html.getViewport("padre").height))/3)+"px";
    _capaFloatingPane.style.left=((parseInt(dojo.html.getViewport("padre").width))/4)+"px";
    
    dojo.html.setClass(_tabla, 'tablaBusqueda');
    _tabla.setAttribute('id', "tablaBusquedaFeatureInfo");
    
    _capaFloatingPane.appendChild(_tabla);
    _capaPadre.appendChild(_capaFloatingPane);
    
    _widgetFloatingPane = dojo.widget.createWidget("dojo:FloatingPane",
    {title: "Informacion",resizable:true, hasShadow:true, displayMinimizeAction:true, 
     executeScripts: true, toggle:"explode",toggleDuration:500},_capaFloatingPane);
     
     this.muestraInformacion = function(urlPeticion, capa, campos){
         _capa = capa;
         _campos = campos;
         
         //var borrarPeticion = "http://192.168.10.245:8080/guiaurbana/wms?VERSION=1.1.1&REQUEST=GetFeatureInfo&BBOX=561505.718,4132156.909011111,561785.968,4132333.186788889&WIDTH=1062&HEIGHT=668&INFO_FORMAT=text/plain&LAYERS=Parcelas%20de%20Urbana.22112&FORMAT=image/png&SRS=EPSG:23030&QUERY_LAYERS=Parcelas%20de%20Urbana.22112&FEATURE_COUNT=1&X=655&Y=248"
         //var borrarPeticion = "http://192.168.10.245:8080/guiaurbana/wms?VERSION=1.1.1&REQUEST=GetFeatureInfo&BBOX=279016.875,4600121.341111111,279297.125,4600297.618888889&WIDTH=1062&HEIGHT=668&INFO_FORMAT=text/plain&LAYERS=Parcelas%20de%20Urbana.22112&FORMAT=image/png&SRS=EPSG:23030&QUERY_LAYERS=Parcelas%20de%20Urbana.22112&FEATURE_COUNT=1&X=223&Y=99";
         //console.log(urlPeticion);
         //console.log(borrarPeticion);
         dojo.io.bind({
             // url: "http://192.168.10.245:8080/visor/busqueda?tipo=vias&idMunicipio=4016&formato=json",
             url: urlPeticion,
             // función que se ejecutará cuando se hayan cargado los datos
             load: function(type, data, evt){
//debugger;
                 // var tmpXML = "<?xml version='1.0'?>" + data;
                 var datosEnXML = (new DOMParser()).parseFromString(data);
                 var datosJSON = [];
                 
                 recorreArbol(datosEnXML, datosJSON);
                 
                 // una vez que tenemos los datos creamos la tabla
                 crearTabla();
                 
                 poblarTabla(datosJSON);
                 // MIRAR SI SE PUEDEN PONER HIPERVINCULOS DENTRO DE UN FILTERING TABLE
             },
             // Función manejadora de errores
             error: function(type, error){ 
                 debugger;
             },
             method: "GET",
             // Tipo de datos que recibiremos
             mimetype: "text/plain"         
         });
         
         _widgetFloatingPane.domNode.style.visibility ="visible";
         
         _widgetFloatingPane.show();
     }
     
     recorreArbol = function(nodosArbolXML, datosJSON){
         //debugger;
         if(nodosArbolXML.childNodes.length>0){
             // recorremos los nodos del arbol en busqueda de que alguno coincida
             // con los campos que nos han especificado
             for(var i=0; i<nodosArbolXML.childNodes.length; i++){
                 for(var j=0; j<_campos.length; j++){
                     //if(nodosArbolXML.childNodes[i].localName == _campos[j].nombre){
			if(nodosArbolXML.localName == _campos[j].nombre){
                         var dato = Object();
                         dato.clave = _campos[j].textoAMostrar;
                         //dato.valor = nodosArbolXML.childNodes[i].textContent;
			dato.valor = nodosArbolXML.textContent;
                         datosJSON.push(dato);
                         break;
                     }
                 }
                 recorreArbol(nodosArbolXML.childNodes[i],datosJSON);
             }
         }
     }
     this.hide = function(){
         //_widgetFloatingPane.hide();
         _widgetFloatingPane.minimizeWindow();
     }
     
     this.destroy = function(){
         //_widgetFloatingPane.hide();
        /* if(_widgetFloatingPane!=null){
             var hijos = _widgetFloatingPane.childNodes;
             var iteraciones = hijos.length;
             for(var i=0; i<iteraciones; i++){
                 _widgetFloatingPane.removeChild(hijos[0]);
             }*/
         //_widgetFloatingPane.destroyChildren();
         if(_widgetFloatingPane!=null){
             //dojo.event.browser.clean(_capaFloatingPane);
             _widgetFloatingPane.destroy();
             _widgetFloatingPane = null;
         }
     }
     crearTabla = function(){
         
         // si la tabla tenia hijos los eliminamos
         var hijosTabla = _tabla.childNodes;
         var iteraciones = hijosTabla.length;
         for(var i=0; i<iteraciones; i++){
             _tabla.removeChild(hijosTabla[0]);
             
         }    
         // creamos el thead y el tbody
         var cabecera = document.createElement("thead");
         var campo = document.createElement("td");
         campo.innerHTML = "CAMPO";
         var contenido = document.createElement("td");
         contenido.innerHTML = "CONTENIDO";
         cabecera.appendChild(campo);
         cabecera.appendChild(contenido);
         
         var cuerpo = document.createElement("tbody");
         
         _tabla.appendChild(cabecera);
         _tabla.appendChild(cuerpo);
         
     }
     poblarTabla = function(datosJSON){
//debugger;
         
         var cuerpo = _tabla.getElementsByTagName("tbody");
         
         if(datosJSON.length>0){
             
             for(var i=0; i<datosJSON.length; i++){
                 var fila = document.createElement("TR");
                 var clave = document.createElement("TD");
                 var valor = document.createElement("TD");
                 
                 clave.innerHTML = datosJSON[i].clave;
                 if(esHiperVinculo(datosJSON[i].valor)){
                     var enlace = document.createElement("a");
                     
                     enlace.target="_blank";
                     enlace.href=datosJSON[i].valor
                     enlace.innerHTML = datosJSON[i].valor;
                     
                     valor.appendChild(enlace);
                 }else{
                     valor.innerHTML = datosJSON[i].valor;
                 }    
                 
                 fila.appendChild(clave);
                 fila.appendChild(valor);
                 cuerpo[0].appendChild(fila);
             }
         }
     }
     
     esHiperVinculo = function(cadena){
         if(cadena.indexOf("http://")!=-1){
             return true;
         }
         return false;
     }
}