/* Constantes o variables de uso global                                       */
/** *************************************************************************** */
var variableblanco;
var featurespuntointeres;
var var1=12268;
		var var2='hola que tal';
var pruebaparaborar;
var debug = false; // Modo debug. Utilizamos <code>alert</code> para las trazas
var map; // Variable en la que se almacenará el mapa a mostrar.
var estadopi = false;// variable global para controlar el estado de los
						// puntos de interes de la capa wfs.
var cambio = false;// variable global para la caja del menu.
var ideruta; // variable global del id de la ruta
var puntosglobal;// variable global para los puntos
var one,dos;
var boundes;
var clickM;


var numeromedicion = 0;
var distanciamedicion=0
var totalmedicion=0;
var popupsmedicion ;
// para ver la visibilidad de las opciones de puntos
var vistapip=false;
var vistahap=false;
var vistaarp=false;
var vistaetp=false;
var vistanap=false;
var clickactivacion=false;//para el click
// var pruebafeature;
var zoom_maximo = 0;
var capasvisibles = new Array();
var featurespuin;
var puin =  false;
var box_ruta = new OpenLayers.Bounds(323208.594106381, 4065130.17054077,328426.076937216, 4067772.51966305);

// bound que se modificara segun la ruta
// var layerpuntosvar="sistur:oce_puntosinteres_23030_con_rutas";//variable para
// la carga de la capa de puntos de interes segun sea shperica o no
// var layerpuntosvar="sistur:pip";//variable para la carga de la capa de puntos
// de interes segun sea shperica o no
// var layerpuntosvar="sistur:oce_puntosinteres_sphe_merc_con_rutas";
var puntosasociados; // variable global de los puntos asociados
var popup; // Popup que mostrará el visor cuando se pulse sobre un feature.
var GEOSERVER_WFS = "/geoserver/wfs"; // Ruta relativa al servidor de WFS.
var GEOSERVER_WMS = "/geoserver/wms"; // Ruta relativa al servidor de WMS.
//var GEOSERVER_WMSC = "http://82.223.155.47:80/geoserver/wms/gwc/services/"; // Ruta relativa al servidor de WMS.
//ESta es la que estaba antes (cache) cuando hay cache. la de abajo
var GEOSERVER_WMSC = "/geoserver/gwc/service/wms/"; // Ruta relativa al servidor de WMS.
// Esta es para cuando no hay cache. la de abajo
//var GEOSERVER_WMSC = "/geoserver/wms";
// Contorno incial para el mapa.
var ANDALUCIA_BOUND_BOX = new OpenLayers.Bounds(-970093.2352852378, 4272677.754939864, -148200.38443207034,	4702634.026901421);
var wgs84_maxExtent = new OpenLayers.Bounds(93070.09999999998, 3978677.624,626914.1, 4291177.624);
var utm_maxExtent= new OpenLayers.Bounds(-1100000, 3000000, 1200000, 5000000);
var rute;
var FORMAT = 'image/png'; // Constante para las capas de datos.
var FORMAT2 = 'image/jpeg'; // Constante para las capas de datos.
if (document.compatMode && document.all && !window.XMLHttpRequest) {
	FORMAT = 'image/gif';
}
var velocidad = 500;// variable para la velocidad de movimiento del menu
var expand, expand2 = false;// variable para comprobar el estado del menu
var ancho;      // se usa para poner el width dinamicamente a la capa
				// #contenedor_bocadillo_puntos
var click = "";
var texto = "";
//JLS siguiente variable comentada
//var box_ruta;
//Fin JLS


/** *************************************************************************** */
/* Definimos las capas de datos que vamos */
/* a utilizar */
/** *************************************************************************** */
/** *************************************************************************** */
/* Definimos las capas de datos que vamos */
/* a utilizar */
/** *************************************************************************** */
/** *************************************************************************** */
/* Definimos un objeto para guardar los nombres de las capas y el umbral de */
/* las mismas asi como el tipo de capa que sera y el grupo al que pertenece */
/** *************************************************************************** */
var activo; // variable que contendrá los campos activo seleccionados por el
			// usuario.
var iconosvisorsinseleccion = new Array("js/map/img/punto_sin_seleccionar1.png");
for (var i=1;i<110;i++){
	iconosvisorsinseleccion.push("/geoserver/images/iconos_visor/"+i+".png")
}
var iconosvisorseleccion = new Array("js/map/img/punto_seleccionado1.png");
for (var i=1;i<110;i++){
	iconosvisorseleccion.push("/geoserver/images/iconos_visor/"+i+".png")
}
var campo1 = new Array();
var campo2 = new Array();
// campo1[0]= {externalGraphic :
// 'http://localhost/andarural/js/map/img/punto_sin_seleccionar1.png',
// graphicHeight : 15, fillOpacity: 1};
// campo2[0]= {cursor:'crosshair', externalGraphic :
// 'http://localhost/andarural/js/map/img/punto_seleccionado1.png',
// graphicHeight : 15, fillOpacity: 1};
for (var i=0;i<110;i++){
campo1[i]= {externalGraphic : iconosvisorsinseleccion[i], graphicHeight : 25, fillOpacity: 1}; 
campo2[i]= {cursor:'crosshair', externalGraphic : iconosvisorseleccion[i], graphicHeight : 25, fillOpacity: 1}; 
}
var topografia = {
        rv_viaria_23030 : {
            nombre : 'rv_viaria_23030',
            capa : 'red_viaria_23030',
            umbral : 500000,
            grupo : 'rv',
            tipo : 'WMS',
            vista : false
        },
        red_hidrica_23030 : {
            nombre : 'red_hidrica_23030',
            capa : 'red_hidrica_23030',
            umbral : 500000,
            grupo : 'rf',
            tipo : 'WMS',
            vista : false
        },
        casco_urbano_23030 : {
            nombre : 'casco_urbano_23030',
            capa : 'casco_urbano_23030',
            umbral : 200000,
            grupo : 'cu',
            tipo : 'WMS',
            vista : false
        },
        curvas_nivel_23030 : {
            nombre : 'curvas_nivel_23030',
            capa : 'curvas_nivel_23030',
            umbral : 500000,
            grupo : 'cn',
            tipo : 'WMS',
            vista : false
        },

        toponimias_23030 : {
            nombre : 'toponimias_23030',
            capa : 'toponimias_23030',
            umbral : 00000,
            grupo : 'tp',
            tipo : 'WMS',
            vista : false
        },
        espacios_naturales_protegidos_23030 : {
            nombre : 'espacios_naturales_protegidos_23030',
            capa : 'espacios_naturales_protegidos_23030',
            umbral : 500000,
            grupo : 'enp',
            tipo : 'WMS',
            vista : false
        },

        red_electrica_23030 : {
            nombre : 'red_electrica_23030',
            capa : 'red_electrica_23030',
            umbral : 25000,
            grupo: 're',
            tipo : 'WMS',
            vista : false
        },

	division_administrativa_23030 : {
		nombre : 'division_administrativa_23030',
		capa: 'division_administrativa_23030',
		umbral : 3000000,
		grupo : 'da',	
		tipo : 'WMS',
		vista : false
		
	},
	
	puntos_alojamientos_es_23030 : {
		nombre : 'alp',
		capa: 'sistur:alp',
		umbral : 500000,
		grupo : 'alp',	
		tipo : 'WFS',
		vista : false
		
	},
	
	puntos_cultura_es_23030 : {
		nombre : 'codp',
		capa: 'sistur:codp',
		umbral : 500000,
		grupo : 'codp',	
		tipo : 'WFS',
		vista : false
		
	},

	puntos_etnograficos_es_23030 : {
		nombre : 'etp',
		capa: 'sistur:etp',
		umbral : 500000,
		grupo : 'etp',	
		tipo : 'WFS',
		vista : false
		
	},

	puntos_actividades_complementarias_es_23030 : {
		nombre : 'acp',
		capa: 'sistur:acp',
		umbral : 500000,
		grupo : 'acp',	
		tipo : 'WFS',
		vista : false
		
	},

	puntos_arqueologicos_es_23030 : {
		nombre : 'arp',
		capa : 'sistur:arp',
		umbral : 500000,
		grupo : 'arp',
		tipo : 'WFS',
		vista : false
	},
 	
	puntos_naturaleza_es_23030 : {
		nombre : 'nap',
		capa : 'sistur:nap',
		umbral : 500000,
		grupo : 'nap',
		tipo : 'WFS',
		vista : false
	},

	puntos_sanidad_es_23030 : {
		nombre : 'ssp',
		capa : 'sistur:ssp',
		umbral : 500000,
		grupo : 'ssp',
		tipo : 'WFS',
		vista : false
	},

	puntos_seguridad_ciudadana_es_23030 : {
		nombre : 'scp',
		capa : 'sistur:scp',
		umbral : 500000,
		grupo : 'scp',
		tipo : 'WFS',
		vista : false
	},

	puntos_servicios_varios_es_23030 : {
		nombre : 'svp',
		capa : 'sistur:svp',
		umbral : 500000,
		grupo : 'svp',
		tipo : 'WFS',
		vista : false
	},
 	
	puntos_transportes_es_23030: {
		nombre : 'tcp',
		capa : 'sistur:tcp',
		umbral : 500000,
		grupo : 'tcp',
		tipo : 'WFS',
		vista : false
	},
	
	puntos_historico_artisticos_es_23030 : {
		nombre : 'hap',
		capa : 'sistur:hap',
		umbral : 500000,
		grupo : 'hap',
		tipo : 'WFS',
		vista : false
	},

	puntos_seguridad_es_23030 : {
		nombre : 'sop',
		capa : 'sistur:sop',
		umbral : 500000,
		grupo : 'sop',
		tipo : 'WFS',
		vista : false
	},
	
	puntos_restaurantes_es_23030 : {
		nombre : 'rsp',
		capa : 'sistur:rsp',
		umbral : 500000,
		grupo : 'rsp',
		tipo : 'WFS',
		vista : false
	},

	rutas : {
		nombre : 'rutas',
		capa : 'sistur:oce_rutas_23030',
		umbral : 500000,
		grupo : 'ru',
		tipo : 'WMS',
		vista : false
	},

	puntos : {
		nombre : 'puntos',
		capa : 'sistur:pip',
		umbral : 500000,
		grupo : 'pip',
		tipo : 'WFS',
		vista : false
	}
}
/*Estilo para el measure*/
var sketchSymbolizers = {
        "Point": {
            pointRadius: 4,
            graphicName: "square",
            fillColor: "white",
            fillOpacity: 1,
            strokeWidth: 1,
            strokeOpacity: 1,
            strokeColor: "#333333"
        },
        "Line": {
            strokeWidth: 3,
            strokeOpacity: 1,
            strokeColor: "#666666",
            strokeDashstyle: "dash"
        }
    };
    var style = new OpenLayers.Style();
    style.addRules([
        new OpenLayers.Rule({symbolizer: sketchSymbolizers})
    ]);
    var styleMap = new OpenLayers.StyleMap({"default": style});

/*funciones para los controles de navegacion*/
OpenLayers.Control.CustomNavToolbar = OpenLayers.Class(OpenLayers.Control.Panel, {
    initialize: function(options) {OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]);
        this.addControls([new OpenLayers.Control.Navigation(), new OpenLayers.Control.ZoomBox({alwaysZoom:true}),new OpenLayers.Control.Measure(
                OpenLayers.Handler.Path, {
                    persist: true,
                    handlerOptions: {
                        layerOptions: {styleMap: styleMap}
                    }
                }
            )]);
		this.displayClass = 'olControlNavToolbar'},draw: function() {var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments);this.activateControl(this.controls[0]);return div;}});
OpenLayers.Control.ZoomOut = OpenLayers.Class(OpenLayers.Control, {
    type: OpenLayers.Control.TYPE_BUTTON,
    trigger: function(){if (zoom_maximo<map.getZoom()){this.map.zoomOut(); }},
		CLASS_NAME: "OpenLayers.Control.ZoomOut" });
OpenLayers.Control.ZoomToMaxExtent = OpenLayers.Class(OpenLayers.Control, {
    type: OpenLayers.Control.TYPE_BUTTON,
    trigger: function() {if (this.map) {this.map.zoomToExtent(box_ruta, true);}},
    CLASS_NAME: "OpenLayers.Control.ZoomToMaxExtent"  });

/*****************************************************************************/
/* Array que utilizaremos para la generacion automatica del icono en el */
/* en el servicio WFS */
/** ************************************************************************** */
var campo = {};
var tamano = 35;
/** ************************************************************************ */

var ICONO_ALTO = 45;
var ICONO_ANCHO = 45;

var ICONOS_REPOSO = 'js/map/img/punto_sin_seleccionar1.png';
var ICONOS_CLIK = 'js/map/img/punto_seleccionado1.png';

var ICONOS_ALOJAMIENTOS = 'js/map/img/icono_alojamientos.png';
var ICONOS_FUENTES = 'js/map/img/icono_fuentes.png';
var ICONOS_PARQUENATURAL = 'js/map/img/icono_parquenatural.png';
var ICONOS_RESTAURANTES = 'js/map/img/icono_restaurantes.png';

var URL_BASE = 'js/map/';
var popupObject; // Variable que se utilizara para mantener los contenidos de
					// los popups.
var featureSelected;

$j.getScript(URL_BASE + 'Popup.js', function() {if (debug)alert('cargado');});
$j.getScript(URL_BASE + 'FeatureEditable.js');
/** *************************************************************************** */
/* Definimos las capas de datos que vamos */
/* a utilizar */
/** *************************************************************************** */

/** *************************************************************************** */
/* Definimos las constantes para el uso de WFS */
/** *************************************************************************** */
var ANDARURAL_SPATIAL_NAME = "andarural";

var COD_PROV_FIELD = "codigo";
var PROV_LAYER = "provincias_23030";
var PROV_LAYER_SPHE_MERC = "provincias_23030";
var COD_COMARC_FIELD = "id_comarca";
var COMARC_LAYER = "comarcas_23030";
var COMARC_LAYER_SPHE_MERC = "comarcas_23030";
var COD_MUNI_FIELD = "cod_ine";
var MUNI_LAYER = "municipios_23030";
var MUNI_LAYER_SPHE_MERC = "municipios_23030";
var ALOJ_LAYER = "alojamientos";

/** ********************************************** */
/* Definimos las clases a usar */
/** ********************************************** */

/** ********************************************** */
/* Clase Propiedad. Permite definir un */
/* Objeto propiedad con su nombre de propiedad */
/* y valor */
/** ********************************************** */
function Property(key, value) {
	this.key = key;
	this.value = value;
}

/*************************************************/
/* Clase Feature */
/* Objeto que almacena las propiedades de */
/* un feature. */
/** ********************************************** */
function Feature(featName, properties) {
	this.featName = featName;
	this.properties = properties;
}

/*************************************************/
/* Clase Layer */
/* Objeto que almacena la informacion */
/* de una capa. */
/** ********************************************** */
function Layer(layerName, features) {
	this.layerName = layerName;
	this.features = features;
}

/*******************************************************/
/* Establecemos las proyecciones que vamos a utilizar */
/** **************************************************** */
var utm = new OpenLayers.Projection('EPSG:23030');
var wgs84 = new OpenLayers.Projection('EPSG:4326');
var gSphMerc = new OpenLayers.Projection('EPSG:900913');

/** **************************************************** */
/* Establecemos Controles y Eventos para los mapas. */
/** **************************************************** */
/** **************************************************** */
/* Establecemos un handler para Click que permite hacer */
/* Efecto de trancision en el click */
/** **************************************************** */
OpenLayers.Control.ClickMapPan = OpenLayers.Class(OpenLayers.Control, {

	defaultHandlerOptions : {
		'single' : true,
		'delay' : 200
	},

	initialize : function(options) {
		this.handlerOptions = OpenLayers.Util.extend( {},
				this.defaultHandlerOptions);
		OpenLayers.Control.prototype.initialize.apply(this, arguments);
		this.handler = new OpenLayers.Handler.Click(
				this, {'click' : this.onClick}, this.handlerOptions);},

	onClick : function(evt) {

	if(clickactivacion!=false){		

 pruebaparaborar = map.getLonLatFromPixel(evt.xy);
 //pruebaparaborar.split(',');
 //alert(pruebaparaborar[0]);
 //alert(pruebaparaborar);
 map.panTo(map.getLonLatFromPixel(evt.xy));
 //cambio de la propiedad para crea tu ruta
 //hay que hacer pruebaas para ver si afecta a otras cuestiones
 //cesar
 layerMarkers = new OpenLayers.Layer.Markers("Markers");
 map.addLayer(layerMarkers);
		
 var lonLat = new OpenLayers.LonLat(pruebaparaborar.lon,pruebaparaborar.lat);
 //map.setCenter (lonLat, 16);
 var size = new OpenLayers.Size(30,30);
 var offset = new OpenLayers.Pixel(-(size.w/2), -size.h);
 var icon = new
 OpenLayers.Icon('js/map/img/punto_seleccionado2.png',size,offset);
 layerMarkers.addMarker(new OpenLayers.Marker(lonLat,icon));
 clickM.deactivate();
 pruebaparaborar = pruebaparaborar.transform(gSphMerc, utm);
 var textX= document.getElementById('coordenadaX');
 var textY= document.getElementById('coordenadaY');
 textX.value=pruebaparaborar.lon;
 textY.value=pruebaparaborar.lat;
	}
	}

});

/** *************************************************************************** */
/* Evento que gestiona la accion del zoom. */
/* Este es el evento encargado de monitorizar la escala que estamos */
/* viendo para habilitar o desabilitar capas de datos. */
/** *************************************************************************** */
OpenLayers.Map.ZoomEvent = function(e) {
	
// if (map.layers[2].visibility){
// if (map.getZoom()<=2) {
// map.setBaseLayer(base);
// map.layers[0].setVisibility(true);
// map.layers[1].setVisibility(true);
// map.layers[2].setVisibility(false);
// }
// }
// else{
// if (map.getZoom()>=5) {
// map.setBaseLayer(base3);
// map.layers[0].setVisibility(false);
// map.layers[1].setVisibility(false);
// map.layers[2].setVisibility(true);
// }
// }
	
/*
 * for ( var layers in map.layers) { for ( var topo in topografia) { ; if
 * (topografia[topo].nombre == map.layers[layers].name) { if
 * (topografia[topo].umbral > this.getScale()) {
 * map.layers[layers].setVisibility(topografia[topo].vista); } else {
 * map.layers[layers].setVisibility(!topografia[topo].vista); } } } }
 */
}
/*******************************************************/
/* Evento de click sobre un mapa para obtener */
/* informacion de una capa */
/** **************************************************** */
OpenLayers.Control.getFeatureClick = function(e) {
	var params = {
		REQUEST : "GetFeatureInfo",
		EXCEPTIONS : "application/vnd.ogc.se_xml",
		BBOX : map.getExtent().toBBOX(),
		X : e.xy.x,
		Y : e.xy.y,
		INFO_FORMAT : 'text/plain',
		QUERY_LAYERS : 'municipios_23030,provincias_23030,comarcas_23030',
		FEATURE_COUNT : 50,
		Srs : 'EPSG:23030',
		Layers : 'municipios_23030,provincias_23030,comarcas_23030',
		Styles : '',
		WIDTH : map.size.w,
		HEIGHT : map.size.h,
		format : FORMAT
	};
	OpenLayers.loadURL(GEOSERVER_WMS, params, this, modificaCombos);
	OpenLayers.Event.stop(e);
}

/******************************************************************************/
/* Obtenemos los puntos que caen en la zona donde se ha realizado un click. */
/* <strong>parametros</strong> */
/* <code>x</code> Posicion X (Req) */
/* <code>y</code> Posicion Y (Req) */
/* <code>layers</code> Array de capas donde buscar features cercanos. (Req) */
/* <code>return: Array</code> Array con las features que estan en el bounding */
/** *************************************************************************** */
function getNodosCercanos(x, y, layers) {
	var nodosCercanos = new Array(); // Array en el que almacenaremos los
										// nodos cercanos.

	// Definimos el bound.
	var pixXYMin = new OpenLayers.Pixel(x - ICONO_ANCHO * 0.5, y + ICONO_ALTO
			* 0.5);
	var pixXYMax = new OpenLayers.Pixel(x + ICONO_ANCHO * 0.5, y - ICONO_ALTO
			* 0.5);

	var lonlatMin = map.getLonLatFromViewPortPx(pixXYMin);
	var lonlatMax = map.getLonLatFromViewPortPx(pixXYMax);

	var bound = new OpenLayers.Bounds(lonlatMin.lon, lonlatMin.lat,
			lonlatMax.lon, lonlatMax.lat);
	//alert("a");
	// Recorremos las capas.
	for ( var layerId in layers) {
		var layer = layers[layerId];

		// Recorremos las features.
		for ( var featureId in layer.features) {
			var feature = layer.features[featureId];
			// alert(feature.geometry);
		   if(feature.geometry!=null){
			if (bound.containsBounds(feature.geometry.getBounds())) {
				nodosCercanos.push(feature);
			}
		   } 
		}
	}
	return nodosCercanos;
}

/*******************************************************/
/* Evento de click sobre el mapa que desencadena */
/* un popup con informaci�n de lugar */
/** **************************************************** */
OpenLayers.Popup.ClickEvent = function(e) {
	// Obtenemos la informacion del server.
	var layers = obtenerInformacionCapa(this, e.xy.x, e.xy.y);
	var test = obtenerTextoCapas(layers);
	crearPopup('test', map.getLonLatFromPixel(e.xy));
	OpenLayers.Event.stop(e);
}

function obtenerTextoCapas(layers) {
	if (layers != null) {
		var text;
		for ( var i = 0; i < layers[0].features[0].length; i++) {
			text += layers[0].features[0].properties[i].key;
			text += layers[0].features[0].properties[i].value;
			text += '<br />';
		}
	} else {
		return null;
	}
}

function obtenerInformacionCapa(layer, x, y) {

	var extent = new OpenLayers.Bounds.fromArray(map.getExtent().toArray());
	// extent = extent.transform(wgs84, utm);
	extent = extent.transform(wgs84, gSphMerc);
	var params = {
		REQUEST : "GetFeatureInfo",
		BBOX : extent.toBBOX(),
		X : x,
		Y : y,
		INFO_FORMAT : 'text/plain',
		//  QUERY_LAYERS: 'andarural:alojamientos',
		QUERY_LAYERS : 'sistur:oce_puntosinteres_sphe_merc',
		FEATURE_COUNT : 50,
		Srs : '23030',
		//Srs: 'EPSG:23030',
		//Layers: 'andarural:alojamientos',
		Layers : 'sistur:oce_puntosinteres_sphe_merc',
		Styles : '',
		WIDTH : map.size.w,
		HEIGHT : map.size.h,
		format : FORMAT
	};
	var layers = new Array();
	OpenLayers.loadURL(GEOSERVER_WMS, params, layers, parseaTexto);
	return layers;
}

/******************************************************************************/
/* M�todo que me premite parsear la cadena de textos que me envia el servicio */
/* de WMS. */
/** *************************************************************************** */
function parseaTexto(req) {
	/* Limpiando la cadena de la peticion ajax */
	var patternBasura = new RegExp(
			'Results for FeatureType \'' +
			// '|[-]+\n' +
			'\|\':' + '\|the_geom = \[GEOMETRY \(MultiPolygon|Point\) with [0-9]+ points\]\n',
			'g');
	var patternSeparadorFeature = new RegExp('[-]+\n[-]+\|[-]+', 'g');
	var patternSeparadores = new RegExp('\n', 'g');
	var valoresRaw = req.responseText.replace(patternBasura, '').replace(
			patternSeparadorFeature, '*').replace(patternSeparadores, '|');


	/*
	 * Parseamos los valores en bruto para obtener los objetos que se nos han
	 * enviado
	 */
	var layers = new Array(); // Array de layers.
	var layer, feature, property; // Definimos las variables que vamos a
									// necesitar en el bucle, capa, entidad y
									// propiedad, sobre las que pivotaremos.
	var registros = valoresRaw.split('|*|');

	for ( var i = 0; i < registros.length; i++) {
		/* Sera una capa nueva cuando no existe '=' */
		if (registros[i].indexOf('=') == -1) {
			// Se trata de un registro de layer.
			layer = new Layer(registros[i], new Array());
			layers.push(layer);
		} else {
			// Se trata de la descripcion de un feature.
			var propiedades = registros[i].split('|');
			feature = new Feature(i, new Array());
			layer.features.push(feature);
			for ( var j = 0; j < propiedades.length; j++) {
				var propName = propiedades[j].split('=')[0].replace(new RegExp(
						' ', 'g'), '');
				var propValue = propiedades[j].split('=')[1].replace(
						new RegExp(' ', 'g'), '');
				property = new Property(propName, propValue);
				feature.properties.push(property);
			}
		}
	}
	return layers;
}

/********************************************************************************/
/* Creamos un popup que mostramos sobre el mapa. */
/* Le pasamos al popup la posicion en la que se ha solicitado que se muestre */
/* la informacion adicional, as� como el texto a mostrar. */
/*                                                                            	*/
/* <strong>parametros</strong> */
/* text : Informacion que vamos a mostra en el popup. */
/* position : Posicion desde la que vamos a mostrar el popup */
/* vuelve : viene del bocadillo con el listado y no queremos destruir este */
/** ***************************************************************************** */
function createPopup(text, position) {
	if ((popup != null)) {
		popupDestroy();
	}
	if (popupObject == null) {
		popupObject = new Popup();
	}
	popup = popupObject.getOpenLayersPopup(position, map.getResolution(), text);
	map.addPopup(popup);
	// popup.events.register("click", map, popupDestroy);
	map.events.register("click", map, popupDestroy);
}

/*******************************************************/
/* Evento de destruccion del popup */
/** **************************************************** */
function popupDestroy(e) {
	if (popup != null) {
		popup.destroy();
		popup = null;
		if (e != null) {
			OpenLayers.Util.safeStopPropagation(e);
		}
	}
}

function popupBack() {
	popupObject.back();
}

/*******************************************************/
/* M�todo que permite modificar las combos de seleccion */
/* En funci�n del lugar donde se pincha. */
/* <strong>parametros</strong> */
/* <code>req</code> req, de la solicitud ajax. */
/* <code>this</code> Contexto que contiene los */
/* controles a manejar. */
/** **************************************************** */
function modificaCombos(req) {
	/* Limpiando la cadena de la peticion ajax */
	var patternBasura = new RegExp(
			'Results for FeatureType \'' +
			// '|[-]+\n' +
			'\|\':' + '\|the_geom = \[GEOMETRY \(MultiPolygon\) with [0-9]+ points\]\n',
			'g');
	var patternSeparadorFeature = new RegExp('[-]+\n[-]+\|[-]+', 'g');
	var patternSeparadores = new RegExp('\n', 'g');
	var valoresRaw = req.responseText.replace(patternBasura, '').replace(
			patternSeparadorFeature, '*').replace(patternSeparadores, '|');


	/*
	 * Parseamos los valores en bruto para obtener los objetos que se nos han
	 * enviado
	 */
	var layers = new Array(); // Array de layers.
	var layer, feature, property; // Definimos las variables que vamos a
									// necesitar en el bucle, capa, entidad y
									// propiedad, sobre las que pivotaremos.
	var registros = valoresRaw.split('|*|');

	for ( var i = 0; i < registros.length; i++) {
		/* Sera una capa nueva cuando no existe '=' */
		if (registros[i].indexOf('=') == -1) {
			// Se trata de un registro de layer.
			layer = new Layer(registros[i], new Array());
			layers.push(layer);
		} else {
			// Se trata de la descripcion de un feature.
			var propiedades = registros[i].split('|');
			feature = new Feature(i, new Array());
			layer.features.push(feature);
			for ( var j = 0; j < propiedades.length; j++) {
				var propName = propiedades[j].split('=')[0].replace(new RegExp(
						' ', 'g'), '');
				var propValue = propiedades[j].split('=')[1].replace(
						new RegExp(' ', 'g'), '');
				property = new Property(propName, propValue);
				feature.properties.push(property);
			}
		}
	}

	// Una vez que tenemos los registros mapeados, pasamos a establecer el valor de los controles.
	
	selectCombosValue(layers[1].features[0].properties[3].value,
			layers[2].features[0].properties[1].value,
			layers[0].features[0].properties[1].value);

}

/*******************************************************/
/* Funcion que permite establecer el valor */
/* seleccionado de un select */
/** **************************************************** */

function selSelectValue(control, valor) {
	for ( var i = 0; i < control.options.length; i++) {
		if (control.options[i].value == valor) {
			control.selectedIndex = control.options[i].index;
		}
	}
}

/*******************************************************/
/* Funci�n para iniciar el mapa en la portada de */
/* Anda Rural. */
/* <strong>Parametros</strong> */
/* <code>divMap</code> Recibe como par�metro la cadena */
/* que contiene el ID de la capa donde se alojar� */
/* el mapa. */
/* <code>navControls</code> Capa donde se pondr�n */
/* los controles de navegaci�n */
/* <code>navZoom</code> Capa donde se pondr�n los */
/* controles de zoom */
/* <code>clickPan</code> Boolean que indica si */
/* se establece el efecto Pan en el evento */
/* click del mapa. */
/** **************************************************** */
function init_portal_map(divMap, navControls, zoomControls, clickPan) {
	// Cargamos el mapa standar.
	initStandarMap(divMap, navControls, zoomControls, clickPan);
	clickactivacion=false;
	// Preparamos el contexto para el evento de click.
	var comboMunicipios = document.getElementById('municipios');
	var comboComarcas = document.getElementById('comarcas');
	var comboProvincias = document.getElementById('provincia');
	var controles = {
		'municipios' : comboMunicipios,
		'provincias' : comboProvincias,
		'comarcas' : comboComarcas
	};
	
    // Cambio de zoom para mostrar el raster o el vectorial

	map.events.register('zoomend', map, OpenLayers.Map.ZoomEvent);
	// Establecemos evento para la carga de informaci�n en el lugar del que se
	// pincha.
	map.events.register('click', controles, OpenLayers.Control.getFeatureClick);
}
/** *************************************************************************** */
/* Funciones para ocultar o visualizar las capas por grupos y modificar menu */
/** *************************************************************************** */
// funcion que realiza un cambio de visibilidad en el mapa a traves del menu
function toggleLayerGroup(control) {
	var c = "";
	var group = control.name;
	var topo;
	var d = false;
	var f = false;
	var grupo = "";
	for ( var t in topografia) {
		topo = topografia[t];
		if (group == topo.grupo) {
			topografia[t].vista = control.checked;
			// c = "label." + topo.grupo + "T";
			c = "label." + topo.grupo;
			// alert(c);
			if (topo.vista == true) {
				$j(c).css( {
					'font' : '700 12px Arial',
					'color' : '#789c44'
				});
				if (d == false) {
					grupo = topo.grupo;
					d = true;
				}
			} else {
				$j(c).css( {
					'font' : '400 11px Arial, Helvetica, sans-serif',
					'color' : '#a0a0a0'
				});
				topografia[t].visible = false;
				if (f == false) {
					grupo = topo.grupo;
					f = true;
				}
			}
		}
	
	}
	if (d == true) {
		construccioncapa(grupo);
	}
	if (f == true) {
		eliminarcapa();
	}
}

/******************************************************************************/
/* Funcion inicial para la carga del visor en la */ 
/* pantalla de detalle. */
/* <strong>Parametros</strong> */
/* <code>divMap</code>El div donde vamos a */
/* cargar el mapa. */
/* <code>navControls</code> Capa donde se pondran */
/* los controles de navegacion */
/* <code>navZoom</code> Capa donde se pondran los */
/* controles de zoom */
/* <code>clickPam</code>Booleano que indica si queremos */
/* el efecto PAM cuando hacemos click sobre el mapa. */
/* <code>idRuta</code>Identificador de la Ruta en la */
/* que queremos centrar el visor. */
/** *************************************************************************** */
function initDetailMap2(divMap, navControls, zoomControls, clickPan, idPunto){
map.destroy();
	url = "/geoserver/wfs?service=WFS&version=1.0.0&request=GetFeature&typename=alp,codp,etp,acp,arp,nap,ssp,scp,svp,tcp,hap,sop,rsp&CQL_FILTER=oc_id="+idPunto+"&srsName=EPSG:23030";
	OpenLayers.loadURL(url, '', this, wfsResponsePunto);
}
function initDetailMap(divMap, navControls, zoomControls, clickPan, idRuta, puntos ,boundderuta){
//	alert(idRuta);
	map.destroy();
// alert(map);
	puntosasociados = puntos.split("#");
	
	boundes = boundderuta.split("#");
	one = new OpenLayers.Bounds(boundes[0], boundes[1], boundes[2], boundes[3]);

	boundes[0] = boundes[0] - 500.0;
	boundes[1] = boundes[1] - 500.0;
	boundes[2] = boundes[2] + 2000.0;
	boundes[3] = boundes[3] + 2000.0;
	dos = new OpenLayers.Bounds(boundes[0], boundes[1], boundes[2], boundes[3]);
	ideruta = idRuta;
  initStandarMap2(divMap, navControls, zoomControls, clickPan, boundderuta);
  clickactivacion=false;
 //   $j("input.enp").click();// se comenta para probar a cargar por otro lado
//	$j("input.rf").click();// se comenta para probar a cargar por otro lado
// $j("input.cn").click();// se comenta para probar a cargar por otro lado
//	$j("input.rv").click();// se comenta para probar a cargar por otro lado
//	$j("input.cu").click();// se comenta para probar a cargar por otro lado
// $j("input.da").click();// se comenta para probar a cargar por otro lado
	$j("input.ru").click();// se comenta para probar a cargar por otro lado
	$j("input.pip").click();// se comenta para probar a cargar por otro lado
	//lanzar();

    // funcion para el movimiento del menu dentro del mapa.
    // toogle --> Funcion que conmuta el codigo html que se encuentra dentro de
	// p
	$j("div#sobreencabezado").click(function(){
		if(expand){
			//click.deactivate();
			$j("div#panel").animate({height: "0px"},velocidad, null, function(){
				$j("div#panel").animate({width: "0px"},10);
				$j("div#sobreencabezado").animate({width: "87px"},velocidad, null, function(){ $j("div#panel").css({overflow : "hidden"})} );
				$j("div#opciones").css({height: "29px", width: "88px"});
				$j("div#opciones2").animate({top:"80px"},velocidad);
				lanzar();
			});
		}else{
			if (expand2){
				$j("div#sobreencabezado2").click();
			}
			$j("div#opciones").css({height: "282px", width: "422px"});
		    $j("div#panel").animate({width: "412px"}, velocidad);
    		$j("div#sobreencabezado").animate({width: "425px"},velocidad);
    		$j("div#panel").animate({height: "268px"},velocidad);
    		$j("div#opciones2").animate({top:"340px"},velocidad);
    		// click.activate();
		}
	expand = !expand;
	
	$j("div#opciones div#sobreencabezado p").toggle();
	}); // fin sobreencabezado
	$j("div#sobreencabezado a").bind("click", function(e) {
		// cancela el comportamiento por defecto
		e.preventDefault();

	});

// -----------------------------------------------------------------------------
//    
	$j("div#sobreencabezado2").click(function(){
		if(expand2){
			//click.deactivate();
			$j("div#panel2").animate({height: "0px"},velocidad, null, function(){
				$j("div#panel2").animate({width: "0px"},10);
				$j("div#sobreencabezado2").animate({width: "87px"},velocidad, null, function(){ $j("div#panel2").css({overflow : "hidden"})} );
				$j("div#opciones2").css({height: "29px", width: "88px"});
			});
		}else{
			if (expand){
				$j("div#sobreencabezado").click();
			}
			$j("div#opciones2").css({height: "282px", width: "211px"});
		    $j("div#panel2").animate({width: "206px"}, velocidad);
    		$j("div#sobreencabezado2").animate({width: "213px"},velocidad);
    		$j("div#panel2").animate({height: "268px"},velocidad);
    		// click.activate();
		}
	expand2 = !expand2;
	$j("div#opciones div#sobreencabezado2 p").toggle();
	}); // fin sobreencabezado
	$j("div#sobreencabezado2 a").bind("click", function(e) {
		// cancela el comportamiento por defecto
		e.preventDefault();
	});

	
} // fin initDetailMap

/* -------------------------------------------------------------------------- */

function controlSelectorMapa(objA) {
	objA.className = "activado";
	switch (objA.id) {
	case "agoogle":
		
		document.getElementById("amapa").className = document.getElementById("aortofoto").className = "desactivado";
		// veragoogle('pruebaQ.html','var1,var2');
		break;
	case "amapa":
		document.getElementById("agoogle").className = document.getElementById("aortofoto").className = "desactivado";
		veramapa();
		break;
	case "aortofoto":
		document.getElementById("agoogle").className = document.getElementById("amapa").className = "desactivado";
		veraortofoto();
		break;
	}
	$j("div#botonera_visor a").bind("click", function(e) {
		// cancela el comportamiento por defecto
		e.preventDefault();
	});
	
}

/* --------------------------------------------------------------------------- */
// Definimos la capa de datos.
// funcion para cargar todas las capas a la vez, se llamaría en inicio del mapa
// y posiblemente en el zoom y en el menu
function construccioncapa(e) {
	// Establecemos que se cargen las capas WMS y WFS a la vez.
	var cargarCapa;
	var capa;
	var lanzar = false;
	for ( var capaId in topografia) {
		capa = topografia[capaId];
		if (capa.vista == true && capa.grupo == e) {
			if (capa.tipo == "WMS") {
				if (capa.grupo == "ru") {
					var a = "oc_id=" + ideruta;
					cargarCapa = new OpenLayers.Layer.WMS(capa.grupo,
							GEOSERVER_WMS, {
								srs : 'EPGS:23030',
								layers : capa.capa,
								styles : '',
								format : FORMAT,
								cql_filter : a,
								transparent : true
							}, {
								buffer : 1,
								isBaseLayer : false
							});

				} else {
					cargarCapa = new OpenLayers.Layer.WMS(capa.grupo,
							GEOSERVER_WMSC, {
								layers : capa.capa,
								styles : '',
								srs : 'EPGS:23030',
								format : FORMAT,
								transparent : true
							}, {
								
//							// buffer : 1,
// isBaseLayer : false
								transitionEffect: 'resize'

							});
				}
				map.addLayer(cargarCapa);// Se anaden las capa suelta al mapa
				topografia[capaId].vista = true;
			} else {
				if (capa.grupo == "pip") {
					topografia[capaId].vista = true;
					//url = "/geoserver/wfs?service=WFS&version=1.0.0&request=GetFeature&typename=sistur:pip&CQL_FILTER=ruta_id="+ideruta+"&srsName=EPSG:23030";
					//OpenLayers.loadURL(url, '', this, wfsResponse);
				//	puin = true;
				} else {
					topografia[capaId].vista = true;
				//	puin = false;
				}
			}
		}
	}

	eliminarcapa();
}
/*
 * funcion destruccion de capa, esta funcion leera todo el array de topografia y
 * eliminara aquella capa que se ha quedado construida y concuerde con el nombre
 * de la misma.
 */

function eliminarcapa() {

	paraeliminar = new Array();
	var nom = "";
	var vis = true;
	var n = 0;

	for ( var num in topografia) {
		nom = topografia[num].grupo;
		vis = topografia[num].vista;

		for ( var div = 0; div < map.layers.length; div++) {
			if (nom == map.layers[div].name && !vis && map.layers[div].CLASS_NAME=="OpenLayers.Layer.WMS") {
				paraeliminar[n] = map.layers[div];
				n++;
			}
		}
	}
	for ( var nu in paraeliminar) {
		map.removeLayer(paraeliminar[nu]);
	}
}

/*
 * Funcion que nos permite inicializar el visor del mapa.
 * 
 */
function initEditMap(divMap, // Div que contiene el mapa
		navControls, // Div que contiene los controles de navegacion
		zoomControls, // Div que contiene los controles de zoom
		clickPan, // scroll en el click.
		idRoute, // Identificador de la ruta.
		idUser // Identificador del usuario.
) {

	log("iniciamos la el mapa de edicion.");
	log("idRoute: " + idRoute);
	log("idUser: " + idUser);

	// Cargamos el mapa standar.
	initStandarMap3(divMap, navControls, zoomControls, clickPan);


}


function carga_scroll(){
	var width = 290;
	var c_scroll= "contenedor_bocadillo_puntos";
	scroll_horizontal(c_scroll,width);
	document.getElementById("en_scrollder").style.visibility="hidden"; // el
																		// izq
																		// está
																		// en la
																		// parte
																		// derecha
																		// y
																		// desplaza
																		// el
																		// contenido
																		// a la
																		// izq

}

function ocultaBocadilloListado(){
	document.getElementById("oculta_puntos").style.display= "none";
}

function volverApuntos (){
	document.getElementById("bocadillo_ficharuta").parentNode.innerHTML= texto;
	document.getElementById("contenedor_bocadillo_puntos").style.width= ancho.toString()+"%";
	// carga_scroll();
}

function encontrado (vector, nomCapa){
	var res=false;
	var i=0;
	while ( (i < vector.length) && (!res) ){
		if (vector[i].layer.name == nomCapa){
			res = true;
		}
		i++;
	}
	return res;
}
/******************************************************************************/
/*
 * Poner la clase al icono del titulo se muestre el icono correspondiente al
 * tipo de punto delante del titulo
 */  
/** *************************************************************************** */

function obtenerTipoPunto(nombreCapa){
	var clase;
	switch (nombreCapa){
		case "puntos": 		clase = "interes"; break;
		case "servicios": 	clase = "servicios"; break;
		
		default: 		clase = "interes";// alert('error, no existe ese
											// nombre de capa'); clase=" ";
	}
	return clase;
}


function clasificarPuntosPorTipo (puntos) {
	var puntosClasificados= new Array();   // nuevo array con los puntos
											// clasificados por tipo de capa
	var indCont;
	var i;
	for (indCont= 0; indCont < puntos.length; indCont++){
		if (!encontrado(puntosClasificados, puntos[indCont].layer.name)) {
			puntosClasificados.push(puntos[indCont]);
			for (i = indCont + 1; i < puntos.length; i++) {
				if (puntos[i].layer.name == puntos[indCont].layer.name) {
					puntosClasificados.push(puntos[i]);
				}
			}
		}
	}
	return puntosClasificados;
} // fin clasificarPuntosPorTipo


/** *************************************************************************** */
/* Metodo que me permite mostrar un bocadillo con el listado de datos de */ 
/* datos seleccionados. */
/* puntos es lo mismo que features */
/** *************************************************************************** */
function mostrarBocadilloListado(puntos, lonlat){
	
    var clase;   								// para el selector css con el
												// cual se pintara el icono
												// correspondiente
	var tipoCapa, tipoCapaAnt = "";   // sera de un tipo u otro segun el
										// nombre de la capa
	ancho= 100;
	texto = '<div id="bocadillo_ficharuta"><a id="cerrar_bocadillo" onclick="popupDestroy()"> </a><div id="oculta_puntos" style="display:block"><div id="contenedor_bocadillo_puntos">';
	puntos= clasificarPuntosPorTipo(puntos);
	var indCont;
// tipoBocadillo = puntos[0].layer.name;
    for (indCont=0; indCont < puntos.length; indCont++){
		clase = obtenerTipoPunto(puntos[indCont].layer.name);
		tipoCapa= puntos[indCont].layer.name;
		if (tipoCapaAnt != tipoCapa) {
			if (tipoCapaAnt != ""){
				texto += "</ul></div>";
				ancho += 100;
			}
			texto += '<div class="bocadillo_puntos"><h4 id="' + clase + '">Puntos de ' + clase + '</h4><ul>';
		}
//	// alert ('nombre punto '+indCont+' en bocadilloListado:
	// '+puntos[indCont].data.nombre);
        texto += '<li><a href="#" onclick="ocultaBocadilloListado();mostrarBocadilloInfo('+ puntos[indCont].data.oc_id +',\'' + puntos[indCont].layer.name +'\',' + lonlat + ',true);" class="info">'+puntos[indCont].data.nombre+'</a></li>';
		tipoCapaAnt= tipoCapa;
    }
	texto += "</ul></div>";     // cierro el ultimo bocadillo

	texto += "</div></div></div>";	// cierro: contenedor_bocadillo_puntos,
									// oculta puntos, bocadillo_ficha_ruta
// texto += '<a href="#" id="en_scrollder"><img
// src="img/bocadillo_puntos/scroll_der.gif" /></a></div>';
    createPopup(texto, lonlat);
	document.getElementById("contenedor_bocadillo_puntos").style.width= ancho.toString()+"%";
  // carga_scroll();
}   /*fin mostrarBocadilloListado*/




/** ************************************************************************* */
 /* muestra la informacion de un punto del mapa en un bocadillo */
 /* distingue cuando viene de un punto o de varios */
 /* Parametros: */
 /* punto: objeto con toda la informacion del punto seleccionado */
 /* lonlat: ubicacion del punto usada por createPopup para ubicar el bocad */
 /* vuelve: si es false se incluye un boton de cerrar y si no un boton para */
 /* volver al bocadillo de multiples puntos */
/** ************************************************************************* */

// function mostrarBocadilloInfo (punto, lonlat, volver) {
function mostrarBocadilloInfo (puntoId, puntoNombreCapa, lonlat, volver) {
    var string = '';
    var jsonObject;
	
// var url = "jsp/portal/gis/datosGis.jsp?ptoId=" + punto.data.oc_id; // Esta
// URL deberia devolver datos JSON
	var url = "jsp/portal/gis/datosGis.jsp?ptoId=" + puntoId; // Esta URL
																// deberia
																// devolver
																// datos JSON
    // lo siguiente es para obtener el icono correspondiente a cada capa
    // Descarga los datos JSON del servidor.
	
    $j.getJSON(url, function(data){
        jsonObject = data;
// tipoPunto= obtenerTipoPunto(punto.layer.name);
        tipoPunto= obtenerTipoPunto(puntoNombreCapa);
        // for para obtener la imagen asociada al punto
      var numero;
  //    alert("b");
        for (var a in features){
         if (features[a].data!=null){
    		if(features[a].data.oc_id==puntoId){
    			if(features[a].data.imagen=="0"){
    			numero = "js/map/img/icono_basicos.png";	
    			}else{
    			numero = "/geoserver/images/iconos_visor/"+features[a].data.imagen+".png";
    				}
    		}
         }
    	}
        
		string = '<div id="bocadillo_ficharuta">';
		if (!volver) {
			string += '<a id="cerrar_bocadillo" onclick="popupDestroy();"> </a>';
		}
        string += '<span class="titulo_bocadilloficharuta"><img src="' + numero + '" width="20" height="20"> ';
        
        if(jsonObject.nombre!='null'){string += jsonObject.nombre;}
        string += '</span><span class="municipio_bocadilloficharuta">';
        if(jsonObject.localidad!='null'){string += jsonObject.localidad;}
        string += '</span><span class="direccion_bocadilloficharuta">'; 
        if(jsonObject.direccion!='null'){string += jsonObject.direccion;}
        string += '</span>';
        
   
        
        for (var img in jsonObject.imagenes){
            string += "<div class=\"img_bocadilloficharuta\"><a href=\"#\"><img src=\"" + jsonObject.imagenes[img].url + 
            "\" width=\"60\" height=\"45\" /></a></div>"; 
        }
        

        
		if (volver){
       		string += '<a href="#" class="volver" onclick="volverApuntos();">volver</a>';
		}
        string += "</div>";
		if (volver) {
			document.getElementById('bocadillo_ficharuta').parentNode.innerHTML= string;
		}
		else {
			createPopup(string, lonlat);
		}
        jsonObject = null;
    });
} 


// fin mostrarBocadilloInfo



/** *************************************************************************** */
/* Funcion que permite mostrar las propiedades (attributes) de */
/* un feature seleccionado. */
/** *************************************************************************** */
function mostrarFeature(feature){
	var lonlat;
	featureSelected = feature;
	//alert(featureSelected.geometry);
	if(featureSelected.geometry!=null){
	$j('#bocadillo_ficharuta a').bind('click', function(e) {e.preventDefault();});
    /*
	 * Comprobamos si hay mas objetos bajo el que estamos.
	 */    
    var layers = new Array();
   // alert("c")
    for(var layerId in map.layers){
        var layer = map.layers[layerId];
        if(layer.CLASS_NAME == 'OpenLayers.Layer.WFS' || 
           layer.CLASS_NAME == 'OpenLayers.Layer.Vector' &&
           layer.getVisibility()){
        	            layers.push(layer);
        }
    }
  //  if (feature.gemetry!=null){
    var pixel = map.getViewPortPxFromLonLat( new OpenLayers.LonLat(feature.geometry.x,feature.geometry.y) );
    var features = getNodosCercanos(pixel.x, pixel.y, layers);
    if(features != null && features.length > 0){
        lonlat = new OpenLayers.LonLat(features[0].geometry.x, features[0].geometry.y);
    	if(features.length == 1){
			mostrarBocadilloInfo (feature.data.oc_id, feature.layer.name ,lonlat, false);
        }else{ 
            mostrarBocadilloListado(features, lonlat);
		}
    }
	}
}

//fin mostrar_feature

/** *************************************************************************** */
/* Funcion comun para la carga del mapa. */
/* <strong>Parametros</strong> */
/* <code>divMap</code>El div donde vamos a */
/* cargar el mapa. */
/* <code>navControls</code> Capa donde se pondr�n */
/* los controles de navegacion */
/* <code>navZoom</code> Capa donde se pondron los */
/* controles de zoom */
/* <code>clickPam</code>Booleano que indica si queremos */
/* el efecto PAM cuando hacemos click sobre el mapa. */
/** *************************************************************************** */
function initStandarMap(divMap, navControls, zoomControls, clickPan) {
	global_navControls = navControls;
	global_zoomControls = zoomControls;
	global_clickPan = clickPan;

	    var bounds = new OpenLayers.Bounds(
        83354.49219, 3966645.50781,
        630615.23438, 4291542.96875
    );
	   var boundsmaxextent = new OpenLayers.Bounds(
               -1215000, 2900000,
               1315000, 5100000
           );

    box_ruta=bounds;
    

    var options = {
            controls: [],
            maxExtent: boundsmaxextent,
            maxResolution: 1490.1964836073923,
            //maxResolution: 9882.8125,
            projection: "EPSG:23030",
            units: 'm'
        };

    // box_ruta = wgs84_maxExtent;
    box_ruta=bounds;
    

	map = new OpenLayers.Map(divMap, options);

	var base =  new OpenLayers.Layer.WMS("fondo_home",GEOSERVER_WMS,
			{
		//cambiar al base_home cuando se arregle el geoserver
		layers: 'fondo_home',
      styles: '',
      height: '216',
      width: '360',
      srs: 'EPSG:23030',
      format: FORMAT
      //tiled: true
  },
  {singleTile: true, ratio: 1, transitionEffect: 'resize'} 
	);


	map.addLayer(base);

	map.setBaseLayer(base);
	map.layers[0].setVisibility(true);


	
	if (navControls != null && navControls != '') {
		map.addControl(new OpenLayers.Control.PanPanel( {
			div : document.getElementById(navControls)
		}));
	} else {
		map.addControl(new OpenLayers.Control.PanPanel());
	}
	
	
	
	map.addControl(new OpenLayers.Control.Navigation());

	
	
	if (zoomControls != null && zoomControls != '') {
		map.addControl(new OpenLayers.Control.ZoomPanel( {
			div : document.getElementById(zoomControls)
		}));
	} else {
		map.addControl(new OpenLayers.Control.ZoomPanel());
	}

	
	
	if (clickPan) {
		var click = new OpenLayers.Control.ClickMapPan();
		map.addControl(click);
		click.activate();
	}
	//Mapabase();
	map.setCenter(bounds, 1);
	map.zoomToExtent(bounds, true);
	zoom_maximo = map.getZoom();
}
/******************************************************************************/
// Funcion que es ejecutada cuando es pulsada la casita del mapa home
// Aqui se retorna al mapa raster01, y se quita el base_grande si estuviera
// activado.
// El resto de la funcion es centrarlo.
/** *************************************************************************** */
function mapGoHome(){
alert("mapGoHome");
// map.setBaseLayer(base);
// map.layers[0].setVisibility(true);
// map.layers[1].setVisibility(true);
// map.layers[2].setVisibility(false);

}

/******************************************************************************/
/* Funcion comun para la carga del mapa. */
/* <strong>Parametros</strong> */
/* <code>divMap</code>El div donde vamos a */
/* cargar el mapa. */
/* <code>navControls</code> Capa donde se pondran */
/* los controles de navegacion */
/* <code>navZoom</code> Capa donde se pondran los */
/* controles de zoom */
/* <code>clickPam</code>Booleano que indica si queremos */
/* el efecto PAM cuando hacemos click sobre el mapa. */
/** *************************************************************************** */
function initStandarMap2(divMap, navControls, zoomControls, clickPan) {
    var options = {
            controls: [],
            //maxExtent: utm_maxExtent,
           // maxResolution: 1490.1964836073923,
           // maxResolution: 9882.8125,
           // maxExtent: new OpenLayers.Bounds(100525.7967866852,3987304.0000870414,621651.8125007654,4288889.000083631),
	    //JLS se cambia maxExtent
	   maxExtent: new OpenLayers.Bounds(100525.7967866852,3987304.0000870414,703695.7967798642,4288889.000083631),
	  //Fin JLS
		//JLS cambio por resolution
            //maxResolution: 2035.648498883126,
	    resolutions: [1178.0664062366777, 589.0332031183389, 294.51660155916943, 147.25830077958472, 73.62915038979236, 36.81457519489618,18.40728759744809, 9.203643798724045, 4.601821899362022, 2.300910949681011, 1.1504554748405056, 0.5752277374202528, 0.2876138687101264, 0.1438069343550632, 0.0719034671775316, 0.0359517335887658, 0.0179758667943829, 0.00898793339719145, 0.004493966698595725],
	    //Fin JLS
            height: '400',
            width: '700',
            numZoomLevels: 19,
            projection: new OpenLayers.Projection('EPSG:23030'),
            units: 'm'
        };

	map = new OpenLayers.Map(divMap, options);
	
	var mapa_base = new OpenLayers.Layer.WMS("Geoserver_layers",
			GEOSERVER_WMSC, {
		//srs : 'EPSG:23030',
		layers : 'base_grande',
		//styles : '',
		//tiled : 'true',
		format : FORMAT2//,
		//transparent : false
	},{
		buffer : 0,
		isBaseLayer : true,
		transitionEffect: 'resize'
	});

	
	var ortofoto = new OpenLayers.Layer.WMS("ortofoto",
			GEOSERVER_WMSC, {
			//	srs : 'EPSG:23030',
				layers : 'fotoandalucia',
				//styles : '',
				format : 'image/jpeg',
				//tiled : 'true',
				//transparent : false
				//prueba JLS
				tiled : 'true',
				tilesOrigin : "100525.7967866852,3987304.0000870414",
				maxResolution : 1189.91015625
				//fin JLS
			}, {
				buffer : 0,
				isBaseLayer : false,
				transitionEffect: 'resize'
			});
	map.addLayers([mapa_base,ortofoto]);
	map.layers[0].setVisibility(true);
	map.layers[1].setVisibility(false);
	
//	 var panel = new OpenLayers.Control.NavToolbar();
//     map.addControl(panel);
     map.addControl(new OpenLayers.Control.MousePosition({}));
     scalebar = new OpenLayers.Control.ScaleLine({});
     map.addControl(scalebar);

	
	if (navControls != null && navControls != '') {
		map.addControl(new OpenLayers.Control.PanPanel( {
			div : document.getElementById(navControls)
		}));
	} else {
	map.addControl(new OpenLayers.Control.PanPanel());
	}
    var movemap = new OpenLayers.Control.Navigation({'zoomWheelEnable':false});
    //movemap.disblezoomWheel();
	map.addControl(movemap);
	
	if (zoomControls != null && zoomControls != '') {
		map.addControl(new OpenLayers.Control.ZoomPanel( {
			div : document.getElementById(zoomControls) }));
	} else {
		map.addControl(new OpenLayers.Control.ZoomPanel());
	}

	
	if (clickPan) {
		click = new OpenLayers.Control.ClickMapPan();
		map.addControl(click);
		click.activate();	
	}
	
	Mapabase();
//JLS estaba en produccion con dos se cambia a one
//	map.zoomToExtent(dos);
         map.zoomToExtent(one);
//fin JLS
	//map.setCenter(dos.centerlonLat, 6);
	//JLS estaba en produccion con se cambia one
        //box_ruta = dos;
	 box_ruta = one;
	//fin JLS
	zoom_maximo = map.getZoom();
	url = "/geoserver/wfs?service=WFS&version=1.0.0&request=GetFeature&typename=sistur:pip&CQL_FILTER=ruta_id="+ideruta+"&srsName=EPSG:23030";
	OpenLayers.loadURL(url, '', this, wfsResponse);
	
	
	/*
	 * if (map.getZoom()>10){ zoom_maximo = 10; }
	 */
	
}
function initStandarMap3(divMap, navControls, zoomControls, clickPan) {
map.destroy();

	 var options = {
	            controls: [],
	            maxExtent: utm_maxExtent,
	           // maxResolution: 1490.1964836073923,
	            maxResolution: 9882.8125,
	            projection: "EPSG:23030",
	            units: 'm'
	        };



//		var options = { 
//			    resolutions: [156543.0339, 78271.51695, 39135.758475, 19567.8792375, 9783.93961875, 4891.969809375, 2445.9849046875, 1222.99245234375, 611.496226171875, 305.7481130859375, 152.87405654296876, 76.43702827148438, 38.21851413574219, 19.109257067871095, 9.554628533935547, 4.777314266967774, 2.388657133483887, 1.1943285667419434, 0.5971642833709717, 0.29858214168548586],
//				projection: new OpenLayers.Projection('EPSG:23030'),
//				//displayProjection :utm,
//				//units : "m",
//				numZoomLevels: 19,
//				//maxExtent: new OpenLayers.Bounds(-970093.2352852378,4272677.754939864,-148200.38443207034,4702634.026901421)
//				maxExtent: new OpenLayers.Bounds(-870093.2352852378, 4272677.754939864, -148200.38443207034, 4702634.026901421)
//				};
		
		map = new OpenLayers.Map(divMap, options);
		//map.updateSize();


//		var gmap = new OpenLayers.Layer.Google("Google Streets", {
//			'sphericalMercator' : true
//		});
//		var gsat = new OpenLayers.Layer.Google("Google Satellite", {
//			type : G_SATELLITE_MAP,
//			'sphericalMercator' : true
//		});
//		var ghyb = new OpenLayers.Layer.Google("Google Hybrid", {
//			type : G_HYBRID_MAP,
//			'sphericalMercator' : true
//		});
//		var gphy = new OpenLayers.Layer.Google("Google Physical", {
//			type : G_PHYSICAL_MAP,
//			'sphericalMercator' : true
//		});
		var mapa_base = new OpenLayers.Layer.WMS("Geoserver_layers",
				GEOSERVER_WMSC, {
			srs : 'EPSG:23030',
			layers : 'base_grande',
			//styles : '',
			//tiled : 'true',
			format : FORMAT2
			//transparent : false
		},{
			buffer : 0,
			isBaseLayer : true,
			transitionEffect: 'resize'
		});

		
		
//		var ortofoto = new OpenLayers.Layer.WMS("ortofoto",
//				GEOSERVER_WMSC, {
//					srs : 'EPSG:23030',
//					layers : 'fotoandalucia',
//					styles : '',
//					format : FORMAT,
//					tiled : 'true',
//					transparent : false
//				}, {
//					buffer : 0,
//					isBaseLayer : false
//				});

		map.addLayer(mapa_base);
		
		map.layers[0].setVisibility(true);
	//	map.layers[1].setVisibility(false);
	
//alert("estoy aqui");
		/*
		 * Comprobamos que los valores de los controles, no sean null o vacios.
		 */
		// Creacion de un panel de control con un ZoomBox con la opcion
		// alwaysZoom establecida a true
	/*	OpenLayers.Control.CustomNavToolbar = OpenLayers.Class(OpenLayers.Control.Panel, {
		
		    initialize: function(options) {
		        OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]);
		        this.addControls([
		          new OpenLayers.Control.Navigation(),
				  //Aqui se pone
		          new OpenLayers.Control.ZoomBox({alwaysZoom:true})
		          
		        ]);
				// para hacer usu del navtoolbar usamos el estilo del
				// navtoolbar, que se modificara en su momento
				this.displayClass = 'olControlNavToolbar'
		    },
		  
		    draw: function() {
		        var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments);
		        this.activateControl(this.controls[0]);
		        return div;
		    }
		});*/
//		map.addControl(new OpenLayers.Control.CustomNavToolbar());	
		map.addControl(new OpenLayers.Control.MousePosition({}));
		map.addControl(new OpenLayers.Control.ScaleLine({}));
		if (navControls != null && navControls != '') {
			map.addControl(new OpenLayers.Control.PanPanel( {
				div : document.getElementById(navControls)
			}));
		} else {
			map.addControl(new OpenLayers.Control.PanPanel());
		}

		// Anadimos la navegacion por defectos con eventos del raton.
		map.addControl(new OpenLayers.Control.Navigation());

		// Anadimos los controles de zoom.
		if (zoomControls != null && zoomControls != '') {
			map.addControl(new OpenLayers.Control.ZoomPanel( {
				div : document.getElementById(zoomControls)
			}));
		} else {
			map.addControl(new OpenLayers.Control.ZoomPanel());
		}

		// Modulo Click Pan
		if (clickPan) {
			clickM = new OpenLayers.Control.ClickMapPan();
			map.addControl(clickM);
			// alert("click");
		}
		Mapabase();
		//error?
		//map.zoomToExtent(boundruta, true);
		////map.zoomToExtent(new OpenLayers.Bounds(-870093.2352852378, 4272677.754939864, -148200.38443207034, 4702634.026901421), true);
		
		// map.zoomToExtent(one, true);
		// map.zoomToExtent(dos, true);
		box_ruta = new OpenLayers.Bounds(
		        83354.49219, 3966645.50781,
		        630615.23438, 4291542.96875
		    );
		// map.zoomToExtent();
		// one="";
		// dos="";
		// alert(one);
		
		
		/*
		 * if (map.getZoom()>10){ zoom_maximo = 10; }
		 */
		map.zoomToExtent(box_ruta, true);
		map.zoomOut();
		zoom_maximo = map.getZoom();
	}
/*******************************************************
 Modifica la vista del mapa para hacer zoom a una provincia.
 Se pasa el codigo de una provincia
 *******************************************************/
 
function modificaVistaProvincia(cod_provincia) {
	var HUELVA = new OpenLayers.Bounds(100686.90637455, 4057142.00008261,
			209582.49989606, 4249584.99996399);
	var ALMERIA = new OpenLayers.Bounds(407686.90637455, 4057142.00008261,
			621582.49989606, 4199584.99996399);
	var CORDOBA = new OpenLayers.Bounds(288117.90637455, 4105240.00008261,
			434601.49989606, 4290001.99996399);

	
	switch (cod_provincia) {
	case '-1':
		map.zoomToExtent(ANDALUCIA_BOUND_BOX, true);
		break;
	case '4':
		map.zoomToExtent(ALMERIA, true);
		break;
	case '14':
		map.zoomToExtent(CORDOBA, true);
		break;
	case '21':
		map.zoomToExtent(HUELVA, true);
		break;
	default:
		getFeatureByName(COD_PROV_FIELD, cod_provincia, ANDARURAL_SPATIAL_NAME,
				PROV_LAYER, centerBounds);
		break;
	}

	
//	
//	if(cod_provincia == '-1'){
//	   map.zoomToExtent(ANDALUCIA_BOUND_BOX, true);
// }
// else{
// if (cod_provincia == '21'){
// // // alert('huelva');
// map.zoomToExtent(HUELVA,true);
// }
//	    
// else{
// getFeatureByName(COD_PROV_FIELD,
// cod_provincia,
// ANDARURAL_SPATIAL_NAME,
// PROV_LAYER_SPHE_MERC,
// centerBounds);
// }
// }
	 
}

/*******************************************************/
/* Modifica la vista del mapa para hacer zoom a una */
/* comarca. */
/* Se pasa el codigo de la comarca. */
/** **************************************************** */
function modificaVistaComarca(cod_comarca) {

	if (cod_comarca != '-1') {

		getFeatureByName(COD_COMARC_FIELD, cod_comarca, ANDARURAL_SPATIAL_NAME,
				COMARC_LAYER, centerBounds);
	}
}

/*******************************************************
 Modifica la vista del mapa para hacer zoom a un municipio.
 Se pasa el codigo de un municipio.
 /** **************************************************** */
function modificaVistaMunicipio(cod_municipio) {

	if (cod_municipio != '-1') {

		
		getFeatureByName(COD_MUNI_FIELD, cod_municipio, ANDARURAL_SPATIAL_NAME,
				MUNI_LAYER, centerBounds);
	}
}

/*******************************************************
 Funcion que nos permite obtener las caracteristicas de un feature.
 Actual mente no devolvemos nada.
 /** **************************************************** */
function getFeatureByName(field, nameFeature, spatialName, layer,
		funcionCallBack) {
	// the layer with the useBbox option 
	var wfsLayer = new OpenLayers.Layer.WFS('Capa de busqueda', layer, {
		typename : spatialName + ':' + layer
	}, {
		typename : spatialName + ':' + layer,
		featureNS : GEOSERVER_WFS,
		useBbox : false,
		projection : utm
	});

	wfsLayer.preFeatureInsert = function(feature) {// alert("test");
	};

	// Establecemos el filtro de busqueda.
	
	wfsLayer.params.FILTER = '<ogc:Filter xmlns:ogc="http://www.opengis.net/ogc">'
			+ '<ogc:PropertyIsEqualTo>'
			+ '<ogc:PropertyName>'
			+ field
			+ '</ogc:PropertyName>'
			+ '<ogc:Literal>'
			+ nameFeature
			+ '</ogc:Literal>' + '</ogc:PropertyIsEqualTo>' + '</ogc:Filter>';
	var url = wfsLayer.getFullRequestString( {}, GEOSERVER_WFS);
	var outlineRequest = new XMLDoc(); // Construir peticion http
	outlineRequest.loadXMLDoc(url, funcionCallBack);
}

/*******************************************************
 Funcion que podemos utilizar como callback, para centrar la vista en un 
 feature.
 Como parametro, pasaremos la respuesta del servidor <code>req</code>
 TODO: Requiere resolver errores de ejecuci0n en IE7
 *******************************************************/
 function centerBounds (req){
	   req = req.request;
	       if(req.responseXML != null){
	        var tmp = req.responseXML.getElementsByTagName('gml:Box');
	        if (tmp[0]!=null){
	        var coorStr = tmp[0].childNodes[0].childNodes[0].data;
	        var coorMin = coorStr.split(' ')[0];
	        var coorMax = coorStr.split(' ')[1];
	        var bounds = new OpenLayers.Bounds(
	             coorMin.split(',')[0],
	             coorMin.split(',')[1],
	             coorMax.split(',')[0],
	             coorMax.split(',')[1]);
		map.zoomToExtent(bounds, false);
 
	        }
	       }
 }
	       
 function obtenerbounds (req){
	 

//	  	var bounds = req.split('#');
// alert(bounds);
// var extent = new OpenLayers.Bounds.fromArray(bounds.toArray());
// alert("A"+extent);
// // extent = extent.transform(wgs84, utm);
// extent = extent.transform(utm, gSphMerc);
// alert("B"+extent);
// // boundruta = new
// OpenLayers.Bounds(bounds[0],bounds[1],bounds[2],bounds[3]);
// // boundruta = boundruta.transform(utm, gSphMerc);
// // alert("boundsruta :"+boundruta);
}
 
function selAlojamiento(alojamientoId) {
	var layer;
	for ( var layers in map.layers) {
		if (map.layers[layers].name == ALOJ_LAYER)
			layer = map.layers[layers];
	}
	selFeature(alojamientoId, layer);
}

/******************************************************************************/
/* Funcion que permite seleccionar un feature de una capa determinada. */
/** *************************************************************************** */
function selFeature(featureId, layer) {
	for ( var featureIndex in layer.features) {
		if (layer.features[featureIndex].data.gid == featureId) {
			var feature = layer.features[featureIndex];
			var control = getControl(layer, 'OpenLayers.Control.SelectFeature');
			control.select(feature);
		}
	}
}

function getControl(layer, clazz) {
	var controls = map.controls;
	for ( var controlsIndex in controls) {
		var control = controls[controlsIndex];
		if (control.layer == layer && control.CLASS_NAME == clazz)
			return control;
	}
}

function log(message) {
	$j('div#log').prepend("<br />" + message);
}

//
// Funcion que permite obtener el valor de un parametro pasado en una url.
//
 
function getLayerNameFromURL(url, param) {
	var regExp = new RegExp(param + '=[A-Za-z]+');
	var tmp = regExp.exec(url);
	var str = tmp.toString();
	str = str.replace(new RegExp(param + '='), '');
	return str;
}

 
//
// Funcion que llamara el equipo de desarrollo para que yo marque
// el feature en el mapa.
//

function seleccionaPuntoMapa(capa, id_punto) {
	for ( var lay in map.layers) {
		if (map.layers[lay].name = "vectorlayer") {
			for (fea in map.layers[lay].features) {
				log(map.layers[lay].features[fea].attributes.id_feature);
				if (map.layers[lay].features[fea].attributes.oc_id == id_punto) { 
					map.layers[lay].selectedFeatures = new Array();
					map.layers[lay].selectedFeatures.push(map.layers[lay].features[fea]);
					map.layers[lay].drawFeature(map.layers[lay].features[fea],'select');
					mostrarFeature(map.layers[lay].features[fea]);
				} else {
					map.layers[lay].drawFeature(map.layers[lay].features[fea],'default');
				}
			}
		}
	}
}


//
//  Esta funcion llama a otra que debe de implementar el equipo de
//  desarrollo para que se deseleccionen los puntos del menu
//  Dicha funcion responde a la siguiente firma:
//  deseleccionaFeaturesMenu()
// 
	
function deseleccionaFeatures() {
	deseleccionaFeaturesMenu();
}

// Funcion para marcar en el menu de la ruta.
// Esta funcion realiza una llamada a otra
// que tendra que implementar el equipo de desarrollo para activar el punto en
// su menu
// Dicha funcion corresponde con la firma:
// cargarPuntosRuta(capa ,id_punto);
function marcarMenuRuta(capa, id_punto) {
	cargaPuntosRuta(capa, id_punto);
}

function deseleccionaFeaturesMenu() {
}

function cargaPuntosRuta(capa, id_punto) {
	log("function cargaPuntosRuta() --> Esta funcion hay que eliminarla para evitar conflictos.<br /> "
			+ capa + " punto " + id_punto);
}

/*************************************************************************************/
/* Funciones para seleccionar todos los puntos de interes asociados a la ruta */
/** ********************************************************************************** */
function wfsResponsePunto(transport) {
	gmlParser = new OpenLayers.Format.GML();
	features = gmlParser.read(transport.responseText);
	  var options = {
	            controls: [],
	            maxExtent: utm_maxExtent,
	           // maxResolution: 1490.1964836073923,
	            maxResolution: 9882.8125,
	            projection: "EPSG:23030",
	            units: 'm'
	        };
	map = new OpenLayers.Map('resizable', options);

	
	
	var mapa_base = new OpenLayers.Layer.WMS("Geoserver_layers",
			GEOSERVER_WMSC, {
		srs : 'EPSG:23030',
		layers : 'base_grande',
		//styles : '',
		tiled : 'true',
		format : FORMAT2,
		transparent : false
	},{
		buffer : 0,
		isBaseLayer : true,
		transitionEffect: 'resize'
	});

	map.addLayer(mapa_base);
	

	map.addControl(new OpenLayers.Control.MousePosition({}));
	map.layers[0].setVisibility(true);

	/*
	 * Comprobamos que los valores de los controles, no sean null o vacios.
	 */
	// Creacion de un panel de control con un ZoomBox con la opcion alwaysZoom
	// establecida a true
/*	OpenLayers.Control.CustomNavToolbar = OpenLayers.Class(OpenLayers.Control.Panel, {
	
	    initialize: function(options) {
	        OpenLayers.Control.Panel.prototype.initialize.apply(this, [options]);
	        this.addControls([
	          new OpenLayers.Control.Navigation(),
			  
	          new OpenLayers.Control.ZoomBox({alwaysZoom:true})
	        ]);
			
			this.displayClass = 'olControlNavToolbar'
	    },
	    draw: function() {
	        var div = OpenLayers.Control.Panel.prototype.draw.apply(this, arguments);
	        this.activateControl(this.controls[0]);
	        return div;
	    }
	});*/
//	map.addControl(new OpenLayers.Control.CustomNavToolbar());	
	map.addControl(new OpenLayers.Control.ScaleLine({}));
	Mapabase();
	
//	if (navControls != null && navControls != '') {
//		map.addControl(new OpenLayers.Control.PanPanel( {
//			div : document.getElementById(navControls)
//		}));
//	} else {
		map.addControl(new OpenLayers.Control.PanPanel());
//	}

	/*Anadimos la navegacion por defectos con eventos del raton.*/
	map.addControl(new OpenLayers.Control.Navigation());

	// Anadimos los controles de zoom.
//	if (zoomControls != null && zoomControls != '') {
//		map.addControl(new OpenLayers.Control.ZoomPanel( {
//			div : document.getElementById(zoomControls)
//		}));
//	} else {
		map.addControl(new OpenLayers.Control.ZoomPanel());
//	}

	// Modulo Click Pan
//	if (clickPan) {
//		click = new OpenLayers.Control.ClickMapPan();
//		map.addControl(click);
//		click.activate();
//	}
	
	
	box_ruta = utm_maxExtent;
	zoom_maximo = 10;

	
	layerMarkers = new OpenLayers.Layer.Markers("Markers");
	map.addLayer(layerMarkers);
	
	var lonLat = new OpenLayers.LonLat(features[0].geometry.x, features[0].geometry.y);
	//map.setCenter (lonLat, 16);
	var size = new OpenLayers.Size(30,30);
	var offset = new OpenLayers.Pixel(-(size.w/2), -size.h);
	var icon = new OpenLayers.Icon('js/map/img/punto_sin_seleccionar1.png',size,offset);
	layerMarkers.addMarker(new OpenLayers.Marker(lonLat,icon));
	
	//posiblemente de error por no haber cargado el marca a tiempo.
	map.setCenter(lonLat, 10);
	box_ruta = features[0].geometry.getBounds();
}
function wfsResponse(transport) {
	
//este for es para evitar que se dupliquen las capas comprobar si funciona correctamente en un futuro
	for (var cp in map.layers){
		if(map.layers[cp].CLASS_NAME == "OpenLayers.Layer.Vector"){map.layers[cp].destroy();}
	}

	// Parseo el resultado del feature
	gmlParser = new OpenLayers.Format.GML();
	features = gmlParser.read(transport.responseText);
	if (puin==true){
		featurespuin = features;
	}else{ 
		var text="features[i].data.oc_id == "+puntosasociados[0];
		for(var i=1; i<puntosasociados.length;i++ ){text +=" && features[i].data.oc_id == "+puntosasociados[i];}
		//listadopuntos = featurespuin
		// el problema que tiene es que no se pueden mesclar los puntos de
		// interes con el resto de puntos, por que por un lado se duplican
		// y no se pueden eliminar o se vuelve loco el sistema.Volver a mirarlo
		// mas adelante y cambiar las base de datos.
		if(featurespuntointeres != undefined){
	    for (var i in features){
	    	for (var j in puntosasociados){
	    		if(puntosasociados[j]==features[i].data.oc_id){
	    
	    	features[i].attributes.imagen = 0;
	    	features[i].data.imagen = 0;	
	    		}
	    	}
	    	if(features[i].attributes.imagen != 0 && features[i].attributes.ruta_id=="-6" && vistahap==true){features[i].destroy();}
	    	if(features[i].attributes.imagen != 0 && features[i].attributes.ruta_id=="-5" && vistaetp==true){features[i].destroy();}
	    	if(features[i].attributes.imagen != 0 && features[i].attributes.ruta_id=="-3" && vistaarp==true){features[i].destroy();}
	    	if(features[i].attributes.imagen != 0 && features[i].attributes.ruta_id=="-7" && vistanap==true){features[i].destroy();}	
	    }
		
			for (var x0 in featurespuntointeres){
				for (var x1 in features){
				 if(featurespuntointeres[x0]!=null){
					if(featurespuntointeres[x0].data.oc_id == features[x1].data.oc_id){
						featurespuntointeres[x0]=null;	
					}
				 }
				}
			 }
			
			var numo;
			for (var x0 in featurespuntointeres){
				numo = features.length;
				if (featurespuntointeres[x0]!=null){
					features[numo]=featurespuntointeres[x0];
				}
			}
		
		}	
	}
	// defino los estilos que utilizare con el feature
	var styleMapSimple = new OpenLayers.StyleMap( {
	});
	styleMapSimple.addUniqueValueRules('default', 'imagen', campo1);
	styleMapSimple.addUniqueValueRules('select', 'imagen', campo2);
	// prepara el layer para introducir el feature
	var layerStyled = new OpenLayers.Layer.Vector("result", {
		styleMap : styleMapSimple
	});

	// anadir estas funciones a la capa vectorial
	layerStyled.addFeatures(features);
	var controlSelPointFeature = new OpenLayers.Control.SelectFeature(
			layerStyled, {
				multiple : false,
				hover : true,
				toggleKey : 'ctrlKey', // ctrl key removes from
				// selection
				multipleKey : 'shiftKey', // shift key adds to
				// selection
				callbacks : {
					click : mostrarFeature
				}
			});

	// anadir la capa vectorial a la layer
	map.addLayer(layerStyled);// Se anaden las capa suelta al mapa
	map.addControl(controlSelPointFeature);
	controlSelPointFeature.activate();
}

function wfsResponse2(transport) {
	// Parseo el resultado del feature
	gmlParser = new OpenLayers.Format.GML();
	features = gmlParser.read(transport.responseText);
	
	// defino los estilos que utilizare con el feature
	var styleMapSimple = new OpenLayers.StyleMap( {
	});
	styleMapSimple.addUniqueValueRules('default', 'imagen', campo1);
	styleMapSimple.addUniqueValueRules('select', 'imagen', campo2);
	// prepara el layer para introducir el feature
	var layerStyled = new OpenLayers.Layer.Vector("result", {
		styleMap : styleMapSimple
	});

	// anadir estas funciones a la capa vectorial
	layerStyled.addFeatures(features);
	var controlSelPointFeature = new OpenLayers.Control.SelectFeature(
			layerStyled, {
				multiple : false,
				hover : true,
				toggleKey : 'ctrlKey', // ctrl key removes from
				// selection
				multipleKey : 'shiftKey', // shift key adds to
				// selection
				callbacks : {
					click : mostrarFeature
				}
			});

	// anadir la capa vectorial a la layer
	map.addLayer(layerStyled);// Se anaden las capa suelta al mapa
	map.addControl(controlSelPointFeature);
	controlSelPointFeature.activate();
}

/*fin de las funciones
 funciones para modificar los mapas */
function veragoogle(pagina,nombres) {
}

function veramapa() {
map.layers[0].setVisibility(true);
map.layers[1].setVisibility(false);
}
function veraortofoto() {
map.layers[0].setVisibility(false);
map.layers[1].setVisibility(true);
}

//funcion para obtener las coordenas del mapa
// esta funcion es llamada desde la pagina de
// crea tu ruta
function obtenerCoordenadasMapa(){
	clickactivacion=true;
	clickM = new OpenLayers.Control.ClickMapPan();
	map.addControl(clickM);
	clickM.activate();
	
}


function deshabilitar(){
var enlace = document.getElementById('aortofoto');
enlace.onClick='';
enlace.style.color='#AAAAAA';

var enlace2 = document.getElementsByTagName('pip');
enlace2.checked=false;

}

/*funcion que elimina el layer result*/

function eliminarlayerresult(){
	for (var i in map.layers){
	/*	if (map.layers[i].name=="result"){
			map.layers[i].destroy();
		}*/
		if (map.layers[i].CLASS_NAME=="OpenLayers.Layer.Vector"){
			//map.layers[i].destroy();
			map.removeLayer(map.layers[i]);
		}
	}
}
function lanzar(){
	//Funcion que tiene que realizar por un lado, la lista de todos los puntos seleccionados,
		eliminarlayerresult();
		vistapip=false;
		vistahap=false;
		vistaarp=false;
		vistaetp=false;
		vistanap=false;
		var lanzar = true;
		var lista="";
           // se comprueba todas las opciones que se encuentre en topografia
			// que cumplan nuestras opciones.
           for ( var i in topografia) {
        	 if (topografia[i].vista==true && topografia[i].tipo=="WFS" && topografia[i].grupo=="pip"){
        		 featurespuntointeres=variableblanco;
        		 url = "/geoserver/wfs?service=WFS&version=1.0.0&request=GetFeature&typename=sistur:pip&CQL_FILTER=ruta_id="+ideruta+"&srsName=EPSG:23030";
					OpenLayers.loadURL(url, '', this, wfsResponsepuntointeres);
					vistapip=true;
        	 }
        	 if (topografia[i].vista==false && topografia[i].tipo=="WFS" && topografia[i].grupo=="pip"){
        		 featurespuntointeres=variableblanco;
        		 vistapip=false;
        	 }
        	 
               if (topografia[i].vista==true && topografia[i].tipo=="WFS" && topografia[i].grupo!="pip"){
               	if(lista == ""){lista += topografia[i].grupo;}else{lista += ","+topografia[i].grupo;}
               	
 /*              	 if (topografia[i].grupo=="hap"){vistahap=true;}
               	 if (topografia[i].grupo=="arp"){vistaarp=true;}
               	 if (topografia[i].grupo=="etp"){vistaetp=true;}
               	 if (topografia[i].grupo=="nap"){vistanap=true;}*/

               	 }}
       if(lista == ""){lanzar = false;}
       	//	else{if(vistapip==true){if(vistahap!=true){lista += ",hap";}if(vistaarp!=true){lista += ",arp";}if(vistaetp!=true){lista += ",etp";}if(vistanap!=true){lista += ",nap";}}}
        if(lanzar == true){url = "/geoserver/wfs?service=WFS&version=1.0.0&request=GetFeature&typename="+lista+"&BBOX="+boundes[0]+","+boundes[1]+","+boundes[2]+","+boundes[3]+"&srsName=EPSG:23030";
		 OpenLayers.loadURL(url, '', this, wfsResponse);}
        
        if(lanzar == false && vistapip == true){
        	url = "/geoserver/wfs?service=WFS&version=1.0.0&request=GetFeature&typename=sistur:pip&CQL_FILTER=ruta_id="+ideruta+"&srsName=EPSG:23030";
			OpenLayers.loadURL(url, '', this, wfsResponse);
			
        }
}
function imagenpunto(idp){
var a;
	for (var a in features){
		if(features[a].data.oc_id==idp){
			if(features[a].data.imagen==0){
			a = "js/map/img/punto_sin_seleccionar1.png";	
			}else{
			a = "/geoserver/images/iconos_visor/"+features[a].data.imagen+".png";
				}
		}
	}
	return a;
}

function cargaCreaTuRuta(rutaId,usuarioId){
	//alert('Este es el dato'+rutaId);
	getFeatureByName('oc_id',rutaId,'sistur','oce_rutas_23030',centerBounds);
	var a = "oc_id=" + rutaId;
	cargarCapa = new OpenLayers.Layer.WMS('ruta',
			GEOSERVER_WMS, {
				srs : 'EPGS:23030',
				layers : 'sistur:oce_rutas_23030',
				styles : '',
				format : FORMAT,
				cql_filter : a,
				transparent : true
			}, {
				buffer : 1,
				isBaseLayer : false
			});
	map.addLayer(cargarCapa);
	url = "/geoserver/wfs?service=WFS&version=1.0.0&request=GetFeature&typename=sistur:pip&CQL_FILTER=ruta_id="+rutaId+"&srsName=EPSG:23030";
	OpenLayers.loadURL(url, '', this, wfsResponse2);
}

function handleMeasurements(event) {
	var geometry = event.geometry;
	var units = event.units;
	var order = event.order;
	var measure = event.measure;
	if (geometry != undefined) {
		lanzarpopupmedicion(event.geometry.components[numeromedicion], measure, units);
	}
	numeromedicion = numeromedicion + 1;
}
function lanzarpopupmedicion(geometry, measure, unidades) {
	if (numeromedicion == 0) {
		totalmedicion = 0;
		distanciamedicion = 0;
	} else {
		totalmedicion = measure.toFixed(3);
		distanciamedicion = totalmedicion - distanciamedicion;
	}
	if (geometry != undefined) {
		lonLat = new OpenLayers.LonLat(geometry.x, geometry.y);
		if (numeromedicion != 0) {
			popupsmedicion.destroy();
		}
//		
//		popupsmedicion = new OpenLayers.Popup.FramedCloud("chicken", lonLat,
//				null, "<div style='font-size:.6em'>Distancia: "
//						+ distanciamedicion +" " +unidades+" <br>Total: " + totalmedicion
//						+ " " +unidades+"<br></div>", null, false, null);

popupsmedicion = new OpenLayers.Popup.FramedCloud("chicken", lonLat,
				null, "<div style='font-size:.7em'>Distancia Total:<br> "+ totalmedicion
						+ " " +unidades+"<br></div>", null, false, null);
		map.addPopup(popupsmedicion);
	}
}
function capaCurvasNive(){
var activar = true;
for (var a in map.layers){
	if (map.layers[a].name == 'curvas_nivel_red_electrica'){
			activar = false;
			map.layers[a].destroy();

	}
}
if (activar == true){
var	cargarCapa = new OpenLayers.Layer.WMS('curvas_nivel_red_electrica',
			GEOSERVER_WMS, {
				layers : 'curvas_nivel_red_electrica',
				styles : '',
				srs : 'EPGS:23030',
				format : FORMAT,
				transparent : true
			}, {
				buffer: 0,
				transitionEffect: 'resize'
			});

map.addLayer(cargarCapa);}// Se anaden las capa suelta al mapa
//topografia[capaId].vista = true;
}
function funcionC(){alert("curvas de nivel");}

function Mapabase(){
	

    var sketchSymbolizers = {
        	"Point": {
            	pointRadius: 5,
            	graphicName: "square",
            	fillColor: "white",
            	fillOpacity: 1,
            	strokeWidth: 1,
            	strokeOpacity: 1,
            	strokeColor: "#333333"
        	},
        	"Line": {
            	strokeWidth: 4,
            	strokeOpacity: 1,
            	strokeColor: "#666666",
            	strokeDashstyle: "dash"
        	}
    };
    var styleInactivo = new OpenLayers.Style();
    styleInactivo.addRules([
        new OpenLayers.Rule({symbolizer: sketchSymbolizers})
    ]);
    var styleMap = new OpenLayers.StyleMap({"default": styleInactivo});

var panelControls = [
 new OpenLayers.Control.Navigation(),
 new OpenLayers.Control.ZoomBox({alwaysZoom:false}),
 new OpenLayers.Control.Measure(OpenLayers.Handler.Path, {persist: true, handlerOptions: {layerOptions: {styleMap: styleMap}} })
];
panelControls[2].events.on({"measure": handleMeasurements,"measurepartial": handleMeasurements});
var toolbar = new OpenLayers.Control.Panel({
   displayClass: 'olControlEditingToolbar2',
   defaultControl: panelControls[0]
   
});
toolbar.addControls(panelControls);
map.addControl(toolbar);


var panel = new OpenLayers.Control.Panel({
	   displayClass: 'olControlEditingToolbar'//,
	   //defaultControl: panelControls[0]
	   
	});
/*var buttonA = new OpenLayers.Control.Button({
 displayClass: "olControlNavigation", trigger: funcionA
});*/
var buttonB = new OpenLayers.Control.Button({
 displayClass: "olControlOverviewMap", trigger: capaCurvasNive
});


panel.addControls([buttonB]);
map.addControl(panel);

//
//var buttonCN = new OpenLayers.Control.Button({displayClass: "olControlCurvaNivel", trigger: capaCurvasNivel}); 
//var panelcapas = new OpenLayers.Control.Panel({
//	   displayClass: 'olControlEditingToolbar3'//,
////	   defaultControl: buttonCN[0]
//	   
//	});
//	panelcapas.addControls([buttonCN]);
//	map.addControl(panelcapas);
//var boundsmaxextent = new OpenLayers.Bounds(
//               -1215000, 2900000,
//               1315000, 5100000
//           );


    

//    var mapOptions = {
//            controls: [],
//            maxExtent: boundsmaxextent,
//            maxResolution: 1490.1964836073923,
//            //maxResolution: 9882.8125,
//            projection: "EPSG:23030",
//            units: 'm'
//        };

var mapa_base = new OpenLayers.Layer.WMS("fondo_home",GEOSERVER_WMS,
			{
		//cambiar al base_home cuando se arregle el geoserver
		layers: 'fondo_home',
      styles: '',
      //height: '216',
      //width: '360',
      srs: 'EPSG:23030',
      format: 'image/jpeg'
      //tiled: true
  },
  {singleTile: true, ratio: 1/*, transitionEffect: 'resize'*/} 
	);
var opcionesMiniMapa = {layers: [mapa_base]}
map.addControl(new OpenLayers.Control.OverviewMap(opcionesMiniMapa));
var loadingpanel = new OpenLayers.Control.LoadingPanel();
map.addControl(loadingpanel);

}

function wfsResponsepuntointeres(transport) {
	// Parseo el resultado del feature
	gmlParser = new OpenLayers.Format.GML();
	featurespuntointeres = gmlParser.read(transport.responseText);
}

function wfsResponselanzar(transport) {
	// Parseo el resultado del feature
	gmlParser = new OpenLayers.Format.GML();
	features = gmlParser.read(transport.responseText);
	/*if (puin==true){
		featurespuin = features;
	}else{ */
		var text="features[i].data.oc_id == "+puntosasociados[0];
		for(var i=1; i<puntosasociados.length;i++ ){text +=" && features[i].data.oc_id == "+puntosasociados[i];}
		//listadopuntos = featurespuin
		// el problema que tiene es que no se pueden mesclar los puntos de
		// interes con el resto de puntos, por que por un lado se duplican
		// y no se pueden eliminar o se vuelve loco el sistema.Volver a mirarlo
		// mas adelante y cambiar las base de datos.
		
	    for (var i in features){
	    	for (var j in puntosasociados){
	    		if(puntosasociados[j]==features[i].data.oc_id){
	    
	    	features[i].attributes.imagen = 0;
	    	features[i].data.imagen = 0;	
	    		}
	    	}
	    	if(features[i].attributes.imagen != 0 && features[i].attributes.ruta_id=="-6" && vistahap==true){features[i].destroy();}
	    	if(features[i].attributes.imagen != 0 && features[i].attributes.ruta_id=="-5" && vistaetp==true){features[i].destroy();}
	    	if(features[i].attributes.imagen != 0 && features[i].attributes.ruta_id=="-3" && vistaarp==true){features[i].destroy();}
	    	if(features[i].attributes.imagen != 0 && features[i].attributes.ruta_id=="-7" && vistanap==true){features[i].destroy();}	
	    }
/*	}*/
	// defino los estilos que utilizare con el feature
	var styleMapSimple = new OpenLayers.StyleMap( {
	});
	styleMapSimple.addUniqueValueRules('default', 'imagen', campo1);
	styleMapSimple.addUniqueValueRules('select', 'imagen', campo2);
	// prepara el layer para introducir el feature
	var layerStyled = new OpenLayers.Layer.Vector("result", {
		styleMap : styleMapSimple
	});

	// anadir estas funciones a la capa vectorial
	layerStyled.addFeatures(features);
	var controlSelPointFeature = new OpenLayers.Control.SelectFeature(
			layerStyled, {
				multiple : false,
				hover : true,
				toggleKey : 'ctrlKey', // ctrl key removes from
				// selection
				multipleKey : 'shiftKey', // shift key adds to
				// selection
				callbacks : {
					click : mostrarFeature
				}
			});

	// anadir la capa vectorial a la layer
	map.addLayer(layerStyled);// Se anaden las capa suelta al mapa
	map.addControl(controlSelPointFeature);
	controlSelPointFeature.activate();
}