function form_umkreissuche(lang){
	if (lang == 'de'){var title = 'Ortslagen - Umkreissuche für Deutschland';}
	else {
		var title = 'Radius search for populated places in Germany';
	};
	Ext.apply(Ext.form.VTypes, {  
	 	'numeric': function(){  
	       
	         /***************************************************************** 
	         DESCRIPTION: Validates that a string contains only valid numbers. 
	         PARAMETERS: 
	            strValue - String to be tested for validity 
	         RETURNS: 
	            True if valid, otherwise false. 
	         ******************************************************************/  
	           var objRegExp  =  /(^-?\d\d*\.\d*$)|(^-?\d\d*$)|(^-?\.\d\d*$)/;  
	           return function(strValue){  
	               //check for numeric characters  
	               return objRegExp.test(strValue);
	           }  
	 	}(),  
	 	'numericText': 'Only numbers are allowed'  
	});

	//ProxyHost definieren
	OpenLayers.ProxyHost= "/cgi-bin/proxy.cgi?url=";	
	
	var introTxt = 'Mit dem Formular können die Orte innerhalb eines frei wählbaren Umkreises ';
	introTxt += 'um eine bestimmte Ortslage f&uuml;r Deutschland recherchiert werden.</br></br>';
	introTxt += 'Die Grundlage f&uuml;r die Recherche bildet das Digitale Landschaftsmodell 1:250 000 (DLM250) ';
	introTxt += 'vom <a href="hhttp://www.geodatenzentrum.de/geodaten/gdz_rahmen.gdz_div?gdz_spr=deu&gdz_akt_zeile=4&gdz_anz_zeile=1&gdz_user_id=0" target="_blank">';
	introTxt += 'Bundesamt f&uuml;r Kartographie und Geod&auml;sie</a>. </br></br></br>';
	
	var searchvalue; var idort; var umkreis;
	
	var ds = new Ext.data.Store({
        /* for cross domain queries */
		id: 'comboStore',
        proxy: new Ext.data.HttpProxy({
            	/*url: 'http://www.visdat.de/php/placesSearch.php?searchstring='+searchvalue*/
		url: 'php/placesSearch.php?searchstring='+searchvalue
        }),
		//url: 'http://www.visdat.de/php/placesSearch.php?searchstring='+searchvalue,
        reader: new Ext.data.JsonReader({
            root: 'rows'
        }, [
            {name: 'name', mapping: 'name'},
            {name: 'bundesland', mapping: 'bundesland'},
            {name: 'kreis', mapping: 'kreis'},
            {name: 'gemeinde', mapping: 'gemeinde'},
            {name: 'gid', mapping: 'gid'},
            {name: 'x', mapping: 'x'},
            {name: 'y', mapping: 'y'}
        ]),
        autoLoad: true
    });
    
    
	
    /*var grid = new Ext.grid.GridPanel({
    	store: ds,
    	height: 200,
    	colModel: new Ext.grid.ColumnModel({
				columns: [
	    		{header: 'name', dataIndex: 'name'},
	    		{header: 'bundesland', dataIndex: 'bundesland'},
	    		{header: 'kreis', dataIndex: 'kreis'},
	    		{header: 'gemeinde', dataIndex: 'gemeinde'}
	    	]
    	})
    });*/
    
    var resultTpl = new Ext.XTemplate(
    	'<tpl for="."><div class="search-item">',
            '<span><h3>{name}</h3></span>',
            'Bundesland: <b><font color="#4e6378">{bundesland}</font></b>',
            ' | Kreis: <b><font color="#4e6378">{kreis}</font></b>',
            ' | Gemeinde: <b><font color="#4e6378">{gemeinde}</font></b>',
        '</div></tpl>' 
    );
    
	var searchTextField = new Ext.form.ComboBox({
		fieldLabel: 'Ortsname',
		store: ds,
		name: 'searchstring',
		id: 'searchstring',
		typeAhead: false,
		minChars: 3,
		queryDelay: 100,
		autoSelect: true,
	    loadingText: 'Searching...',
		width: 400,
		hideTrigger: true,
		triggerAction: 'all',
		hideMode: 'offsets',
		enableKeyEvents: true,
		labelStyle: 'text-align: right; font-weight: bold;',
		tpl: resultTpl,
		itemSelector: 'div.search-item', 
		mode: 'local',
		forceSelection: true,
		listeners: {
			keyup: function(combo,e){
				searchvalue = Ext.getCmp('searchstring').getValue();
				/*combo.store.proxy.url = 'http://www.visdat.de/php/placesSearch.php?searchstring='+searchvalue;*/
				combo.store.proxy.url = 'php/placesSearch.php?searchstring='+searchvalue;
				combo.store.removeAll();
				combo.store.totalLength = 0;
				// force the reload on trigger
				combo.lastQuery = null;
				combo.store.reload({params: { searchstring: combo.getValue()}});
			},
			select: function(combo,record){
				combo.setValue(record.data['name']+' ('+ record.data['bundesland']+ ', ' +record.data['kreis'] +')');
				hiddenValueField.setValue(record.data['gid']); // Zuweisung GID zu hiddenValueField
				if(Ext.getCmp('umkreisField').getValue() > 0 && Ext.getCmp('umkreisField').getValue() <= 100 ){
					Ext.getDom('loadingmask100').style.visibility='visible';
					umkreissuche(record.data['gid'], Ext.getCmp('umkreisField').getValue());
					
				}
			}
		}
	});
	
	var umkreisTextField = new Ext.form.TextField({
		id: 'umkreisField',
		fieldLabel: 'Umkreis (km)',
		labelStyle: 'text-align: right; font-weight: bold;',
		width: 50,
		vtype: 'numeric',
		validationDelay: 100,
		enableKeyEvents: true,
		listeners: {
			keyup: function(el,val){
				if(el.getValue()>50){
					el.setValue(0);
					Ext.Msg.alert('Hinweis', 'Umkreis <50 km.');
				}
				else if(el.getValue()<= 100 && el.getValue() > 0 && Ext.getCmp('hiddenValueField').getValue() != '') {
					Ext.getDom('loadingmask100').style.visibility='visible';
					umkreissuche(Ext.getCmp('hiddenValueField').getValue(),el.getValue());
				}
			}
		}
	});
	
	var hiddenValueField = new Ext.form.TextField({
		id: 'hiddenValueField',
		hidden: true
	})
	
	var searchForm = new Ext.form.FormPanel({
		id: 'searchFormPanel',
		items: [searchTextField, umkreisTextField, hiddenValueField]
	});
	
	var tablayout = {
		layout: 'table',
		layoutConfig: {
        	columns: 2
    	},
    	items:[{
    		html: introTxt,
    		colspan: 2
    	},{
    		items: searchForm
    	}]
	};
	
	var searchresults = {
		id: 'showresults',
		layout: 'table',
		layoutConfig: {
			columns: 2
		},
		items: [{
			id: 'resultgrid',
			border: false,
			items: {
				border: false
			}
		},{
			id: 'resultmap',
			border: false,
			items: {
				html: "<div id='map1' style='width:320; height:290;'></div>"
			}
		}]
	};	
    
	var coordPanel = new Ext.Panel({
		title: title,
		id: 'umkreissuchePanel',
		width: 700,
		height: 500,
		frame: true,
		style: {marginLeft: '10px', marginTop: '10px'},
		items: [
			tablayout
			, searchresults
			]
	});
	
	
	
	return coordPanel;
}

function umkreissuche(idort, umkreis){
	
	var ds_umkreis = new Ext.data.Store({
		id: 'store_umkreis',
        proxy: new Ext.data.HttpProxy({
        	//url: 'http://www.visdat.de/php/placesSearch02.php?locid=25000&r=10'
            	/*url: 'http://www.visdat.de/php/placesSearch02.php?locid='+idort+'&r='+umkreis+'&'*/
		url: 'php/placesSearch02.php?locid='+idort+'&r='+umkreis+'&'
        }),
        reader: new Ext.data.JsonReader({
            root: 'rows'
        }, [
            {name: 'ortslage', mapping: 'ortslage'},
            {name: 'bundesland', mapping: 'bundesland'},
            {name: 'kreis', mapping: 'kreis'},
            {name: 'gemeinde', mapping: 'gemeinde'},
            {name: 'ortslage_umkreis', mapping: 'ortslage_umkreis'},
            {name: 'distanz', mapping: 'distanz', type: 'float'},
            {name: 'x', mapping: 'x'},
            {name: 'y', mapping: 'y'}
        ]),
        listeners:{
        	load: function(store){
        		//alert(lo.getCount());
        		umkreisMap(store);
        		/*lo.each(function(re){
        			alert(re.fields[1]);
        		})*/
        	}
        },
        autoLoad: true
    });
    
    	

    
	var grid = new Ext.grid.GridPanel({
    	store: ds_umkreis,
    	id: 'results_umkreissuche',
    	height: 290,
    	colModel: new Ext.grid.ColumnModel({
				columns: [
	    		{header: 'Ortslage', dataIndex: 'ortslage_umkreis', sortable: true},
	    		//{header: 'Bundesland', dataIndex: 'bundesland', sortable: true},
	    		{header: 'Kreis', dataIndex: 'kreis'},
	    		{header: 'Distanz', dataIndex: 'distanz', xtype: 'numbercolumn', format: '0,000.00 km', sortable: true}
	    	]
    	})
    });
    
    
    var c = Ext.getCmp('resultgrid');
	if (c.items.items.length) {
	    c.remove(c.items.items[0]);
	};
	c.add({
		items: grid
	});

	c.doLayout();
}

function umkreisMap(ds_umkreis){

	
	var ergebnisLayer =  new OpenLayers.Layer.Vector();
	var centerLayer = new OpenLayers.Layer.Vector();
	
	ergebnisLayer.setName('ergebnisLayer');
	centerLayer.setName('centerLayer');
	
	var hw;
	var rw;
	var centerPoint;
	
	ds_umkreis.each(function (r){
		rw = parseFloat(r.data['x']);
		hw = parseFloat(r.data['y']);
		var rw_erg;
		var hw_erg;
		rw_erg = rw + 0.0000000000000001;
		hw_erg = hw + 0.0000000000000001;
	
	
			//Koordinatenumrechnung in sphericalMercator
		function lonLatToMercator(ll) {
			var lon = ll.lon * 20037508.34 / 180;
	        var lat = Math.log(Math.tan((90 + ll.lat) * Math.PI / 360)) / (Math.PI / 180);
	        lat = lat * 20037508.34 / 180;
	    return new OpenLayers.LonLat(lon, lat);
		}
		//centerLayer führ Einfärben des zentralen Ortes für die Umkreissuche
		if(r.data['distanz']<0.1){//0.00000000000000000000){
			centerPoint = new OpenLayers.LonLat(rw, hw);

		// so machen damit in ie7 vectorLayer korrekt angezeigt wird	
			var lonLat = new lonLatToMercator(new OpenLayers.LonLat(rw, hw));
			var point_wkt = 'POINT('+lonLat.lon+' '+lonLat.lat+')';
			parser = new OpenLayers.Format.WKT();
			var point_feat = parser.read(point_wkt);						
			centerLayer.addFeatures(point_feat);
			//ergebnisLayer.addFeatures(point_feat); 
			
		// so machen damit in ie7 vectorLayer korrekt angezeigt wird	
			var lonLat_erg = new lonLatToMercator(new OpenLayers.LonLat(rw_erg, hw_erg));
			var point_wkt_erg = 'POINT('+lonLat_erg.lon+' '+lonLat_erg.lat+')';
			parser_erg = new OpenLayers.Format.WKT();
			var point_feat_erg = parser_erg.read(point_wkt_erg);						
			//centerLayer.addFeatures(point_feat);
			ergebnisLayer.addFeatures(point_feat_erg);			

		}else{
		//Layer für die Ergebnisse der Umkreissuche
		    var lonLat = new lonLatToMercator(new OpenLayers.LonLat(rw, hw));
			var point = new OpenLayers.Geometry.Point(lonLat.lon, lonLat.lat);
			var pointFeature = new OpenLayers.Feature.Vector(point,null,null);
			ergebnisLayer.addFeatures(pointFeature);
		}
	});


	
	buildMap = function(mapName, zoomLevels, projection, displayProjection, mapUnits, maxExtent, restrictedExtent, centerMap, startZoom, minScale){
		var map = new OpenLayers.Map(mapName, {
			controls: [],
			id: mapName,
			numZoomLevels: zoomLevels,
		    projection: projection,
		    displayProjection: displayProjection,
		 	units: mapUnits,
		 	//minScale: minScale,
			maxExtent: maxExtent,
			restrictedExtent: restrictedExtent,
			allOverlays: false,
			resolutions: [156543.03390000001, 78271.516950000005, 39135.758475000002, 19567.879237500001, 9783.9396187500006, 4891.9698093750003, 2445.9849046875001, 1222.9924523437501, 611.49622617187504, 305.74811308593752, 152.87405654296876, 76.43702827148438, 38.21851413574219, 19.109257067871095, 9.5546285339355475, 4.7773142669677737, 2.3886571334838869, 1.1943285667419434, 0.59716428337097172, 0.29858214168548586]
		});
	
		//Control
	 	map.addControl(new OpenLayers.Control.Navigation({'zoomWheelEnabled': true}));
		map.addControl(new OpenLayers.Control.Attribution());
		
		return map;
	};
	
	
	f_maxExtent = function (minx,miny,maxx,maxy) {
		var ol_extent = new OpenLayers.Bounds(minx,miny,maxx,maxy);
		return ol_extent;
	};
	
	f_restrictedExtent = function (minx,miny,maxx,maxy) {
		var ol_extent = new OpenLayers.Bounds(minx,miny,maxx,maxy);
		return ol_extent;
	};
	
	f_projection = function (epsg) {
		var projection = new OpenLayers.Projection(epsg);
		return projection;
	};
	
	f_centerMap = function (minx,miny,maxx,maxy){
		var centerX = (minx+maxx)/2;
		var centerY = (miny+maxy)/2;
			 
		var centerMap = new OpenLayers.LonLat(centerX, centerY);
		return centerMap;
	};

	f_mapPanel  = function (zielElement){
	
	//Problem im IE8 w und h werden nicht erkannt 
	var w = parseInt(((Ext.getDom(zielElement).style.width).split('px'))[0]);
	var h = parseInt(((Ext.getDom(zielElement).style.height).split('px'))[0]);
	var mapPanel = new Ext.Panel({
		id: 'mapPanel',
		cls: 'empty',
		border: true,
		height: 290,
		width: 320,
		renderTo: zielElement
	});
	mapPanel.on('afterrender', setTimeout(function(){Ext.getDom('loadingmask100').style.visibility='hidden'},500), this, {delay:5000});
};

	f_mapComponent = function (map, tbar, bbar){
		var mapComponent = new mapfish.widgets.MapComponent({
			id: 'mapComponent',
	        layout: 'fit',
			map: map,
			width: Ext.getCmp('mapPanel').getWidth(),
			height: Ext.getCmp('mapPanel').getHeight(),
	        tbar: tbar,
	        bbar: bbar,
		    border: true,
		    applyTo: 'mapPanel'
		/*	listeners: {
				afterrender: function(){
					var store = Ext.getCmp('results_umkreissuche');
					Ext.StoreMgr.each(function(r){
						alert(r.id);
					});
				}
			}*/
		});
	}
		
	buildLayer = function (map, layerArray, projection){
	    for(var i = 0; i < layerArray.length; i++)
	    {
	    	var layerTyp = layerArray[i][0];
	    	var layerName = layerArray[i][1];
	    	var layerUrl = layerArray[i][2];
	
	    	switch (layerTyp){
	    		case 'Google':  if(layerName == 'Google Physical'){
	    						    var layer = new OpenLayers.Layer.Google(
						                layerName, // the default
						                {'sphericalMercator': true, type: G_PHYSICAL_MAP, 'isBaseLayer': true, displayInLayerSwitcher: false}
						           ); 
						          //map.addLayer(layer);
						          /*var layer = new OpenLayers.Layer.Google(
						                layerName, // the default
						                {'sphericalMercator': true, 'isBaseLayer': false}
						           );*/
						    
	    						}
	    						else {
	    							if(layerName == 'Google Streets'){
	    								var layer = new OpenLayers.Layer.Google(
							                layerName, // the default
							                {'sphericalMercator': true, 'isBaseLayer': false}
						           		); 
	    							}
	    							else {
	    								if(layerName == 'Google Satellite'){
	    									var layer = new OpenLayers.Layer.Google(
							                layerName, // the default
							                {'sphericalMercator': true, type: G_SATELLITE_MAP, 'isBaseLayer': true}
							            	); 
	    								};
	    								if(layerName == 'Google Hybrid'){
	    									var layer = new OpenLayers.Layer.Google(
							                layerName, // the default
							                {'sphericalMercator': true, type: G_HYBRID_MAP, 'isBaseLayer': true}
							            	);
	    								}
	    							}
	    							
	    						};
	    						break;
				case 'OSM':		if(layerName =='OpenStreetMap'){
					           		var layer = new OpenLayers.Layer.OSM(
	              				 	 	"OpenStreetMap",
	                					"http://tah.openstreetmap.org/Tiles/tile/${z}/${x}/${y}.png",
	                					{displayInLayerSwitcher: false},
	                					{'isBaseLayer': layerArray[i][7]}
	                 				              
	           					 	);
	
								};
	
								break;
				case 'WMS':		var layer = new OpenLayers.Layer.WMS(layerName, 
							        layerUrl, 
							        {layers: layerName, transparent: 'true'}, 
							        {'isBaseLayer': layerArray[i][7], projection: projection}
							    );
							    break;
							    
				case 'GML': 	var layer = new OpenLayers.Layer.GML(layerName, 
			    					layerUrl,
			    					{'spericalMercator': true, projection: 'EPSG:4326'},
			    					{'isBaseLayer': layerArray[i][7], reproject: true}
			    				
		    					);	
		    					break;	
		    					
		  		case 'TMS':		/*var layer = new OpenLayers.Layer.WMS(layerName,
		  							layerUrl,
			    					{layers: layerName,
									format: 'image/png'}
								);*/
		  		
		  		  		
		  						var layer = new OpenLayers.Layer.TMS(layerName,
		  							layerUrl,
			    					{serviceVersion: "1.1.1",
			    					layername: layerName,
			    					isBaseLayer: layerArray[i][7], type: "png"}
			    				);	
			    				break;
		  		case 'Mapnik':	function osm_getTileURL(bounds) {
		  
									var res = this.map.getResolution();
									//alert(bounds.left);
						            var x = Math.round((bounds.left - map.maxExtent.left) / (res * this.tileSize.w));
						            var y = Math.round((map.maxExtent.top - bounds.top) / (res * this.tileSize.h));
						            var z = this.map.getZoom();
						            var limit = Math.pow(2, z);
					                x = ((x % limit) + limit) % limit;
					                return this.url + z + "/" + x + "/" + y + "." + this.type;
						        }
	
	
			  						var layer = new OpenLayers.Layer.TMS(layerName,
			  							layerUrl,
				    					{serviceVersion: "1.1.1",
				    					getURL: osm_getTileURL,
				    					displayOutsideMaxExtent: true,
				    					isBaseLayer: layerArray[i][7],
				    					type: "png",
									attribution: '<a href="http://www.openstreetmap.org/">OpenStreetMap</a>'}
				    				);	
	    				
			    				
	    	};
	    	map.addLayer(layer);
			
			
		}
		if (map.baseLayer){
			map.baseLayer.setVisibility(false);
		}
		
	};	

	f_tbar = function (map, height, tbarHidden, tbarArray, treemodel, layerArray, layertree){
		var toolbar = new mapfish.widgets.toolbar.Toolbar({
			id: 'toolbar',
			map: map, 
			configurable: true,
			height: height,
			hidden: tbarHidden
		});
		addTbarActions(map, toolbar,tbarArray, treemodel, layerArray, layertree);
		return toolbar
	};

	addTbarActions = function (map, toolbar, tbarArray, treemodel, layerArray, layertree)
	{
		for(var i = 0; i < tbarArray.length; i++)
		{
			switch(tbarArray[i][0]) {
				case 'ZoomIn': toolbar.addControl(
									new OpenLayers.Control.ZoomBox({
											title: tbarArray[i][1]
							        }), {
							            iconCls: 'zoomin',
							            id: 'zoomin-btn',
							            toggleGroup: 'map',
							          	handler: function(){
													if(Ext.getCmp('queryWindow')){
														Ext.getCmp('queryWindow').close();
													};
													if (Ext.getCmp('measure-btn')){
														if (Ext.getCmp('measure-btn').pressed == true){
								                    					Ext.getCmp('measure-btn').toggle();
								                    					auswahlMessen('Aus');
								                				}
													}
							            				}
							            }
								); break;
				case 'ZoomOut': toolbar.addControl(
									new OpenLayers.Control.ZoomBox({
											title: tbarArray[i][1],
											out:  true
							        }), {
							            iconCls: 'zoomout', 
							            id: 'zoomout-btn',
							            toggleGroup: 'map',
							            handler: function(){
												if(Ext.getCmp('queryWindow')){
													Ext.getCmp('queryWindow').close();
												};
												if (Ext.getCmp('measure-btn')){
							   						if (Ext.getCmp('measure-btn').pressed == true){
								                    				Ext.getCmp('measure-btn').toggle();
								                    				auswahlMessen('Aus');
								                			}
												}
							            	}
							             }
								); break;
								
				case 'DragPan': toolbar.addControl(
								new OpenLayers.Control.DragPan({
						        		isDefault: false,
						        		title: tbarArray[i][1]
								}), {
						            iconCls: 'pan', 
						            id: 'drag-btn',
						            toggleGroup: 'map',
						            handler: function(){
											if(Ext.getCmp('queryWindow')){
												Ext.getCmp('queryWindow').close();
											};
											if (Ext.getCmp('measure-btn')){ 
												if (Ext.getCmp('measure-btn').pressed == true){
										                    	Ext.getCmp('measure-btn').toggle();
						                    					auswahlMessen('Aus');
						                				}										
							            			}
										}
						            }
							); break;
							
				case 'MaxExtent': toolbar.addControl(
									new OpenLayers.Control.ZoomToMaxExtent({
							        		map: map,
							                title: tbarArray[i][1]
									}), {
										iconCls: 'zoomfull', 
										id: 'max-btn',
							            toggleGroup: 'map'
							            }
								); break;
				case 'Measurement': toolbar.add({
										xtype: 'tbsplit',
										id: 'measure-btn',
										iconCls: 'measureicon', 
										title: tbarArray[i][1],
										menu: [{
											text: 'Linien',
											name: 'Linien',
											checked: false,
											group: 'measure',
											listeners: {
												click: function(){
								                    auswahlMessen('Linien');
								                    if (Ext.getCmp('measure-btn').pressed == false){
								                    	Ext.getCmp('measure-btn').toggle();
								                    }
								                }
											}
										},{
											text: 'Flächen',
											name: 'Flächen',
											checked: false,
											group: 'measure',
											listeners: {
												click: function(){
								                    auswahlMessen('Flächen');
								                    if (Ext.getCmp('measure-btn').pressed == false){
								                    	Ext.getCmp('measure-btn').toggle();
								                    }
								                }
											}
										},{
											text: 'Aus',
											name: 'Aus',
											checked: true,
											group: 'measure',
											listeners: {
												click: function(){
								                    auswahlMessen('Aus');
								                    if (Ext.getCmp('measure-btn').pressed == true){
								                    	Ext.getCmp('measure-btn').toggle();
								                    }
								                }
											}
										}],
										arrowHandler: function(){
							        			if(Ext.getCmp('queryWindow')){
													Ext.getCmp('queryWindow').close();
												};
												if (Ext.getCmp('drag-btn').pressed == true){
													Ext.getCmp('drag-btn').toggle();
												}
												if (Ext.getCmp('zoomin-btn').pressed == true){
													Ext.getCmp('zoomin-btn').toggle();
												}
												if (Ext.getCmp('zoomout-btn').pressed == true){
													Ext.getCmp('zoomout-btn').toggle();
												}
												if (Ext.getCmp('max-btn').pressed == true){
													Ext.getCmp('max-btn').toggle();
												}
										}
									}); break;
				case 'LayerTree': toolbar.addControl(new OpenLayers.Control.Button({
							            title: tbarArray[i][1]
							        }), {
							        	xtype: 'tbbutton',
							        	id: 'layer-btn',
							            iconCls: 'layericon', 
							            cls: 'x-btn-icon',
							            handler: function(){
							            	Ext.getCmp('layer-btn').toggle();  
							            	
							               	if(this.pressed == true){	
							         	  		buildLayerTree(map, treemodel, layerArray);
							            	}
							            	
							            	if(this.pressed == false){	
										if(Ext.getCmp('layertreewindow')){
							            			Ext.getCmp('layertreewindow').close();
										};
							            	}
							            }
							        });break;
				case 'Legend': toolbar.addControl(new OpenLayers.Control.Button({
							            title: tbarArray[i][1]
							        }), {
							        	id: 'legend-btn',
							            iconCls: 'legendicon', 
							            cls: 'x-btn-icon',
							            handler: function(){
											Ext.getCmp('legend-btn').toggle();  
							            	
							            	if(this.pressed == true){	
							            		showLegend(layerArray, layertree); 
							            	}
							            	
							            	if(this.pressed == false){	
							            		Ext.getCmp('legendWindow').close();
							            	}
							        }
							        }); break;
				case 'Query': toolbar.addControl(new OpenLayers.Control.Button({
					           			title: tbarArray[i][1]
					        		}), {
							        	id: 'query-btn',
							            iconCls: 'queryicon', 
							            cls: 'x-btn-icon',
							            handler: function(){
							            	Ext.getCmp('query-btn').toggle();  
							            	
							            	if(this.pressed == true){	
							        			if(Ext.getCmp('queryWindow')){
													Ext.getCmp('queryWindow').close();
												};
												if(Ext.getCmp('attributeWin')){
							           				Ext.getCmp('attributeWin').close();
	
							           			};
												showQuery(map, layerArray); 
												if (Ext.getCmp('drag-btn').pressed == true){
													Ext.getCmp('drag-btn').toggle();
												}
												if (Ext.getCmp('zoomin-btn').pressed == true){
													Ext.getCmp('zoomin-btn').toggle();
												}
												if (Ext.getCmp('zoomout-btn').pressed == true){
													Ext.getCmp('zoomout-btn').toggle();
												}
												if (Ext.getCmp('max-btn').pressed == true){
													Ext.getCmp('max-btn').toggle();
												}
								                if (Ext.getCmp('measure-btn').pressed == true){
								                    Ext.getCmp('measure-btn').toggle();
								                    auswahlMessen('Aus');
								                }
							        		};
							            	
								        	if(this.pressed == false){
							           			if(Ext.getCmp('attributeWin')){
							           				Ext.getCmp('attributeWin').close();
								            	};
								            	if(Ext.getCmp('queryWindow')){
								            		Ext.getCmp('queryWindow').close();
								            	}
							            	};
							            }
							        }
		    					); break;
		    	case 'Attribute': toolbar.addControl(new OpenLayers.Control.Button({
							            title: tbarArray[i][1]
							        }), {
							        	xtype: 'tbbutton',
							        	id: 'attribute-btn',
							            iconCls: 'icon_attributes', 
							            cls: 'x-btn-icon',
							        	handler: function(){
							        		Ext.getCmp('attribute-btn').toggle();
							        		if(this.pressed == true){	
							        			if(Ext.getCmp('attributeWin')){
													Ext.getCmp('attributeWin').close();
												};
												if(Ext.getCmp('queryWindow')){
							           				Ext.getCmp('queryWindow').close();
							           			};
												showAttributetable(map, layerArray);
							        		}
	
							        		if(this.pressed == false){
							           			if(Ext.getCmp('queryWindow')){
							           				Ext.getCmp('queryWindow').close();
								            	};
								            	if(Ext.getCmp('attributeWin')){
								            		Ext.getCmp('attributeWin').close();
								            	}
							            	};
							            }
							        });	break;
				case 'Print':	toolbar.addControl(new OpenLayers.Control.Button({
					           			title: tbarArray[i][1]
					        		}), {
							        	id: 'print-btn',
							            iconCls: 'printicon', 
							            cls: 'x-btn-icon',
							            toggleGroup: 'map',
							            handler: function(){
	
							            }
							        }
		    					); break;   
		    	case 'Help':	toolbar.addControl(new OpenLayers.Control.Button({
					           			title: tbarArray[i][1]
					        		}), {
							        	id: 'help-btn',
							            iconCls: 'helpicon', 
							            cls: 'x-btn-icon',
							            toggleGroup: 'map',
							            handler: function(){
	
							            }
							        }
		    					); break;
		    	case 'Spacer':  toolbar.add(new Ext.Toolbar.Button({xtype: 'tbspacer',disabled: true}));
							        
			}
		}
		
	//--------------------------------------------------------------------------------------------
	//Funktionalität für case 'Measurement' in der Toolbar
		var control;
		
		function messen(key){
				if (control != null) {
					control.deactivate();
				};
		        
			measureControls = {
				line: new OpenLayers.Control.Measure(
		        			OpenLayers.Handler.Path, {
		                		persist: true,
		                		geodesic: true
		                	}
				),
		              	
				polygon: new OpenLayers.Control.Measure(
		                   		OpenLayers.Handler.Polygon, {
		                       		persist: true,
		                       		geodesic: true, 
		                       		handlerOptions: {}
		                   		}
				)
			};
		            
			control = measureControls[key];
			control.events.on({
				"measure": handleMeasurements,
				"measurepartial": handleMeasurements
				
			});
		
			map.addControl(control);
			
				
			function handleMeasurements(event) {
				
				var geometry = event.geometry;
				var units = event.units;
		        var order = event.order;
		        var measure = event.measure;
		        //alert(OpenLayers.Util.approxPolyAreaOnSphere(measure.toFixed(3)));
		        var out = "";
		        if(order == 1) {
		        	out += "Länge: " + measure.toFixed(3) + " " + units;
					} else {
		            	out += "Fläche: " + measure.toFixed(3) + " " + units + "<sup>2</" + "sup>";
		          	};
		        
		        var d = Ext.getCmp('meswin');
		        if (d.items.items.length) {
		    		d.remove(d.items.items[0]);
				};
				d.add({items: {html:out, border: false}});
				d.doLayout();
			}
			
			control.activate();	
		};
		function auswahlMessen(geo) {
	
			function open_win(){
				//var h =Ext.getCmp('mapPanel').getPosition();
				var mwin = new Ext.Window({
		        	layout:'fit',
		        	id: 'meswin',
		            x: 300,
		            y: 300,
		            width:150,
		            height:100,
		            items: {border: false},
		            plain: true
		        });
		        
		        mwin.on('close', function() {
					control.deactivate();
					Ext.getCmp('meswin').close();
					if(Ext.getCmp('measure-btn').pressed == true){
						Ext.getCmp('measure-btn').toggle();
					};
				});
		        
				mwin.show(this);
			};
			
	
			
			if(!Ext.getCmp('meswin')){
				open_win();
				//alert(Ext.getCmp('center').getPosition());
			};
					
			switch (geo) {
				case 'Linien': 				
					messen('line');	
				break;
				case 'Flächen': 
					messen('polygon');
				break;
				case 'Aus': 
					control.deactivate();
					Ext.getCmp('meswin').close();
				break;
				default: 
					//control.deactivate();		
			};
		};
	//--------------------------------------------------------------------------------------------
	//--------------------------------------------------------------------------------------------	
		return toolbar;
	};

	f_bbar = function (map, height, bbarHidden, bbarArray){
		var bbar = new Ext.Toolbar({
			id: 'bbar', 
			configurable: false,
			height: height,
			hidden: bbarHidden
		    //items: [bottomitem1,'->', bottomitem2,' ' ,bottomitem3]
		});
			bbar.addItem({
				id:'sline',
				xtype:'box',
				el: 'bbarDiv'
			});
	
	addBbarActions(map, bbar, bbarArray);
		return bbar
	};
	
	addBbarActions = function (map, bbar, bbarArray){
		
		for(var i = 0; i < bbarArray.length; i++){
			
			switch(bbarArray[i][0]) {
				case 'ScaleLine':	
						map.addControl(new OpenLayers.Control.ScaleLine({div: document.getElementById(bbarArray[i][2]),eBottom: ''}));
						break;
				
				case 'MousePosition':
						map.addControl(new OpenLayers.Control.MousePosition({div: document.getElementById(bbarArray[i][2]), numDigits:2, prefix:"X: ", separator:" Y: "}));
						break;
				case 'Label':
						//tabBbar.getElementById(bbarArray[i][2]).innerHTML = bbarArray[i][1];
				document.getElementById(bbarArray[i][2]).innerHTML = 'powered by <a href="http://www.de/" target="_blank">'+bbarArray[i][1]+'</a>';
	
			}
		}
	}


	showLayerTree = function(layertree, layerArray){
	
		// Fenster öffnen
		// Prüfen, ob Fenster schon geöffnet
		if(!Ext.getCmp('layertreewindow')){
		
			var win; 
			if(!win){ 
				win = new Ext.Window({
					id: 'layertreewindow',
		            //layout: 'fit',
		            title: 'Themenauswahl',
		            sizeable: true,
		            width:300,
		            height:250,
		            border: false,
		            hideMode: 'visibility',
		            autoScroll: true,
		            closable: true,
		            //cls: 'querywindow',
		            items: {border: false, autoScroll: true}
				});
				
			var c = Ext.getCmp('layertreewindow');
	        if (c.items.items.length) {
	    		c.remove(c.items.items[0]);
			};
			c.add({items: layertree});
			c.doLayout();
				
			}; 
					
		}else {
			var win = Ext.getCmp('layertreewindow');
		};
		
		win.on('close', function() {
			
			if(Ext.getCmp('layer-btn').pressed == true){
		   		Ext.getCmp('layer-btn').toggle();
		   	}
		});
		if(Ext.getCmp('layer-btn').pressed == true){
			win.show(this);
		};
		
		
		/*function buildCheckbox(layerArray){
			
				for (var z = 1; z<layerArray.length; z++){
				var checkId = layerArray[z][1];
				
				Ext.getDom(checkId).setAttribute('type','checkbox');
				//alert(Ext.getDom('ext-gen56'));
				
				//Ext.getDom(checkId).style.type ='checkbox';
			//var r = this.el.up('.x-column-inner').child('input[name=' + this.el.dom.name + '][value=' + v + ']', true);
	
			}//alert( Ext.getCmp('layertree').el.up('.x-column-inner').child('input[name=tk100][]', true)); 
			//Ext.getDom('tk100').getEl().dom.setAttribute('type','checkbox');
			//alert(Ext.get.getElementsByTagName("INPUT")['tk100']); 
			
		}
			Ext.getCmp('layertreewindow').addListener('afterrender', buildCheckbox(layerArray));
			*/
			
			
		//ersten aktiven Layer im Layertree hervorheben
		for(var z=0; z<layerArray.length; z++){ 
	 	 	if (layerArray[z][5] == true){
				var nodes = layertree.root.eachChild(function(currentNode){
					 currentNode.eachChild(function(currentNode2){
					 		if(currentNode2.id == layerArray[z][1]){
					 					 			
			 					currentNode2.getUI().addClass('node_sel');
			 					currentNode2.getUI().getIconEl().className = 'queryicon_small';
			 				}
					 });
	
			 	});
			}
	 	}
		
	};


	buildLayerTree = function (map, treemodel, layerArray){
	
		
		var layertree = new mapfish.widgets.LayerTree({
		  rootVisible: false,
		  id: 'layertree',
		  map: map,
		  border: false,
		  bodyBorder: false,
		  autoScroll: true,
		  model: treemodel,
		  listeners: {    
		   	checkchange: function(n){
		
		  		
							// Aktualisierung Legende
							if(Ext.getCmp('legendWindow')){
						  		if (Ext.getCmp('legendWindow').items.items.length) {
								    Ext.getCmp('legendWindow').remove(Ext.getCmp('legendWindow').items.items[0]);
								}; 
								Ext.getCmp('legendWindow').add({
									items:[{html: buildLegendPanel(layerArray, layertree)}]
						  		});
						  		Ext.getCmp('legendWindow').doLayout();
						  	}
						  						  	
		   	},
	
	   		click: function(t){
	   		
					var activeLayerId = t.attributes.id;
				   		for(var i = 0; i < layerArray.length; i++){
					    	layerArray[i][5] = false;
					    	var layerName = layerArray[i][1];
					    	if (layerName == activeLayerId){
					    		layerArray[i][5] = true;
					    		if (layerArray[i][4] == true){
	
					    			
					    			 var nodes = this.root.eachChild(function(currentNode){
					    			  currentNode.eachChild(function(currentNode2){
					    			  		
					    			  		currentNode2.getUI().addClass('node_unsel');
					    			  		if(currentNode2.getUI().getIconEl()) {
					    			  			currentNode2.getUI().getIconEl().className = 'queryicon_small_hide';
					    			  		}
					    				    			  	
					    			  	
					    			  });
		 
					    			});
	
					    	
					    			
					    		/*	alert(this.root.eachChild(function(currentNode){
					    			  currentNode.id}));*/
					    		
									t.getUI().removeClass('node_unsel');
									t.getUI().addClass('node_sel');
					    			t.getUI().getIconEl().className = 'queryicon_small';
					    	
	
					    		}
					    	
					    	}
				    	};
	
					if(map.getControl('hoverCtrl')){
						map.getControl('hoverCtrl').deactivate();
			   			map.getControl('hoverCtrl').unselectAll();
						map.removeControl(map.getControl('hoverCtrl'));
					};
					
					var allLayers = map.layers;
					var numLayers = map.getNumLayers(); 
				
					
					for(i = 0; i < numLayers; i++){
					
								
					if(map.getControl('selectCtrl')){
						map.getLayer(allLayers[i].id).events.remove('featureselected');	
						map.getControl('selectCtrl').deactivate(); 
						map.removeControl(map.getControl('selectCtrl'));
					}
					}
				
							// Aktualisierung Abfragefenster
							if(Ext.getCmp('queryWindow')){
						  		if (Ext.getCmp('queryWindow').items.items.length) {
								    Ext.getCmp('queryWindow').remove(Ext.getCmp('queryWindow').items.items[0]);
								}; 
								Ext.getCmp('queryWindow').add({
									items:[{html: initQuery(map, layerArray), border: false}]
						  		});
						  		Ext.getCmp('queryWindow').doLayout();
						  	};
				
					  	
						  	if(Ext.getCmp('attributeWin')){
						  		initAttributetable(map, layerArray);
							
						  	}
	
	   				},
	   				expandnode: function(t){
	   					
	   					for(var i =0; i < t.childNodes.length; i++){
	  				
							if(t.childNodes[i].parentNode.id!='source'){ 
		   						
		   						for(var z = 0; z < layerArray.length; z++){
		   							if((t.childNodes[i].id == layerArray[z][1]) && layerArray[z][7]==true){
		   								Ext.getDom(t.childNodes[i].id).setAttribute('type','checkbox');
		   							}
		   						}
							}
	   					}
	   				}
			}
			
		 });
		 
		if (Ext.getCmp('layer-btn')){
			showLayerTree(layertree, layerArray);
		};
	
		
		return layertree;
	};

	buildLegendPanel = function (layerArray, layertree){
	var request = '';
		
		var checkedlayers = layertree.getChecked();
	
		for (var i=0; i<layerArray.length; i++){
			var layername = layerArray[i][1];
					
			var url = layerArray[i][3];
			if (url != null && layername != null){
				for (var k=0; k<checkedlayers.length; k++){
				
					if (checkedlayers[k].text == layername){
						
						request += '<img src='+url+'&SERVICE=WMS&VERSION=1.1.1&layer='+layername+'&REQUEST=getlegendgraphic&FORMAT=image/png>';
						request += '<br>';
					}
				}
	
			}
		}
		
		return request;
	};

	showLegend = function (layerArray, layertree) {
		
		
		if(!Ext.getCmp('legendWindow')){
			var win; 
			if(!win){ 
				win = new Ext.Window({
					id: 'legendWindow',
		            layout: 'auto',
		            title: 'Legende',
		            sizeable: true,
		            width:200,
		            height:310,
		            autoScroll: true,
		            items: [{html: buildLegendPanel(layerArray, layertree)}]
		            //,legend // Standard cgi-Legende
				});
			};
		}
		else {
			var win = Ext.getCmp('legendWindow');
		}
		win.on('close', function() {
	   		
	   		if(Ext.getCmp('legend-btn').pressed == true){
		   		Ext.getCmp('legend-btn').toggle();
		   	}
	   		
		});
		win.show(this);
	};

	init = function(){
		
			//Div-Elemente für Bottombar erzeugen //Eigenschaften sind in custom.css definiert
		
		var bbarDiv = document.createElement('div');
		bbarDiv.id = "bbarDiv";
		document.body.appendChild(bbarDiv);
		
		var bbarLeft = document.createElement('div');
		bbarLeft.id = "bbarLeft";
		document.getElementById('bbarDiv').appendChild(bbarLeft);
		
		var bbarMid = document.createElement('div');
		bbarMid.id = "bbarMid";
		document.getElementById('bbarDiv').appendChild(bbarMid);
		
		var bbarRight = document.createElement('div');
		bbarRight.id = "bbarRight";
		document.getElementById('bbarDiv').appendChild(bbarRight);
		
	}

	initQuery = function (map, layerArray){
		
		var layerName;
		var request;
		var qryURL;
	
		for(var k = 0; k < layerArray.length; k++){
			
			if (layerArray[k][5] == true && layerArray[k][4] == true){
				layerName = layerArray[k][1];
				
				var allLayers = map.layers;
				var numLayers = map.getNumLayers(); 
				request = '';
				
				if(layerArray[k][0]=='GML'){
							
					for(var i = 0; i < numLayers; i++){
						if(allLayers[i].name == layerName){
							// Hover Control
						    var hoverCtrl = new OpenLayers.Control.SelectFeature(map.getLayer(allLayers[i].id),
								{hover: true,
								id: 'hoverCtrl',
								highlightOnly: true
							});  
						    map.addControl(hoverCtrl); 
							hoverCtrl.activate(); 
									
						if(map.getControl('selectCtrl')){
							map.getLayer(allLayers[i].id).events.remove('featureselected');	
							map.getControl('selectCtrl').deactivate(); 
							map.removeControl(map.getControl('selectCtrl'));
						}		    	
							// Select Control
							var selectCtrl = new OpenLayers.Control.SelectFeature(map.getLayer(allLayers[i].id),
								{clickout: false, 
								id: 'selectCtrl',
								hover: false
							});  
							
							map.addControl(selectCtrl); 
							selectCtrl.activate(); 					
							
							map.getLayer(allLayers[i].id).events.on({
					        	featureselected: function(e) {
					        		//Aufruf der nutzerspezifischen Funktion createHtml
					        		request = createHtml(e, layerName, qryURL);
					        
					        // Aktualisierung Abfragefenster
							if(Ext.getCmp('queryWindow')){
						  		if (Ext.getCmp('queryWindow').items.items.length) {
								    Ext.getCmp('queryWindow').remove(Ext.getCmp('queryWindow').items.items[0]);
								}; 
								Ext.getCmp('queryWindow').add({
									items:[{html: request, border: false}]
						  		});
						  		Ext.getCmp('queryWindow').doLayout();
						  	};
					        		
					            }
					        	
					        });
		
						}
				
					}
				}
	
				if(layerArray[k][0]=='WMS'){
					
					for(var i = 0; i < numLayers; i++){
						if(allLayers[i].name == layerName){	
							var layerId = allLayers[i].id;
											
							map.events.register('click',map,function(e){
								var ll = new OpenLayers.Pixel(e.xy.x-1,e.xy.y+1);
								var ur = new OpenLayers.Pixel(e.xy.x+1,e.xy.y-1); 	
								var mapll = map.getLonLatFromPixel(ll);
								var mapur = map.getLonLatFromPixel(ur);
								var proj2 = new OpenLayers.Projection("EPSG:31468");
								mapll.transform(map.getProjectionObject(), proj2);
								mapur.transform(map.getProjectionObject(), proj2);
								
								// Abfrage von Feature aus der GML Datei auf Grundlage der BoundingBox 
									qryURL = map.getLayer(layerId).getFullRequestString({
									REQUEST: "GetFeature",
									EXCEPTIONS: "application/vnd.ogc.se_xml",
									BBOX: new OpenLayers.Bounds(mapll.lon,mapll.lat,mapur.lon,mapur.lat).toBBOX(),
									X: e.xy.x,
									Y: e.xy.y,
									INFO_FORMAT: 'text/html',
									QUERY_LAYERS: map.getLayer(layerId).params.LAYERS,
									WIDTH: map.getLayer(layerId).map.size.w,
									HEIGHT: map.getLayer(layerId).map.size.h,
									VERSION: '1.0.0',
									SERVICE : 'WFS',
									TYPENAME: map.getLayer(layerId).params.LAYERS
								});	
								//Aufruf der nutzerspezifischen Funktion createHtml
								request = createHtml(null, layerName, qryURL);	
								
							});
						}		
					}
				}
			}
		}
		return request;
	}

	showQuery = function (map, layerArray){
		
	if(map.getControl('hoverCtrl1')){
		map.getControl('hoverCtrl1').deactivate();
		map.getControl('hoverCtrl1').unselectAll();
	}
		
	//Abfragefenster
	
	
		if(!Ext.getCmp('queryWindow')){
				var win; 
				if(!win){ 
					win = new Ext.Window({
						id: 'queryWindow',
			            layout: 'fit',
			            title: 'Abfragefenster',
			            sizeable: true,
			            resizable: false,
			            width:300,
			            height:340,
			            x: 50,
			       		items: [{html: initQuery(map, layerArray)}]
					});
					
					
				};
			}
			else {
				var win = Ext.getCmp('queryWindow');
				win.doLayout();
			};
	
			win.on('close', function() {
		   		Ext.getCmp('query-btn').toggle(); 
		   		
		   		if(map.getControl('hoverCtrl')){
			   		map.getControl('hoverCtrl').deactivate();
			   		map.getControl('hoverCtrl').unselectAll();
			   		map.removeControl(map.getControl('hoverCtrl'));
			   		map.getControl('hoverCtrl1').activate();
		   		};
		   		
	
			});
	
			win.show(this);
	};


	initAttributetable = function (map, layerArray){
		var attributeGrid;
	
		//Abfrage welcher Layer ist aktiv?
		for(var k = 0; k < layerArray.length; k++){
			
			if (layerArray[k][5] == true && layerArray[k][4] == true){
				layerName = layerArray[k][1];
				
				var allLayers = map.layers;
				var numLayers = map.getNumLayers(); 
				//Reihenfolge der Layer muss neu geordnet werden, so dass highlightFeature-Layer oben liegt
				for(ii= 0; ii<numLayers;ii++){
					if(allLayers[ii].name==layerName){
						var abc = allLayers[ii];
						map.removeLayer(allLayers[ii]);
						map.addLayer(abc);
					}
				};
		
			//ERstellen des Layers für das "Highlighten" (wenn Zeile im Abfrage-Grid selektiert wird)	
			var myPartnerStyles = new OpenLayers.StyleMap({
	        	'default': new OpenLayers.Style({
		        	pointRadius: 6,
		        	fillColor: "blue", 
		        	strokeColor: "darkblue", 
		        	fillOpacity: 0.5, 
		        	strokeWidth: 2
	        	})
			});
	       
			var highlightFeature = new OpenLayers.Layer.Vector("highlightFeature", 
		    	{'spericalMercator': true, 
		    	projection: "EPSG:4326", styleMap: myPartnerStyles},
		    	{displayInLayerSwitcher: false,
	            visibillity: true,
	            isBaseLayer: false, 'reproject': true}
	        );
	        highlightFeature.id = 'highlightFeature';
	        map.addLayer(highlightFeature);
	     
	        
	        if(layerArray[k][0]=='GML'){
	        
		        //zum abfragen muss der bereits bestehende Abfragelayer hier ein zweites mal erstellt werden
		        var atr_layer = new OpenLayers.Layer.GML(layerName, 
					layerArray[k][2],
					{'spericalMercator': true, projection: 'EPSG:4326'},
					{'isBaseLayer': false, reproject: true}
				);	
				
				var urlParse = layerArray[k][2];
			
					
				//Funktion wird bei click auf Zeile im Attribut-Grid aufgeführt
				function connectMap(sm,index,record){
		
					var Nummer = record.data.gid; 
				
					OpenLayers.loadURL(urlParse, "", null, parseData);
		     
			        function parseData(req) {
			        	g =  new OpenLayers.Format.GML({url: urlParse});
						var features = g.read(req.responseText);
				
						for(var beschreibung in features) {
			
							for (var j in features[beschreibung].attributes) {
					
									if (features[beschreibung].attributes[j]==Nummer){
											hw = features[beschreibung].attributes['hw'];
											rw = features[beschreibung].attributes['rw'];
																				
									};
							};
							
						};
						
						//Koordinatenumrechnung in sphericalMercator
						function lonLatToMercator(ll) {
							var lon = ll.lon * 20037508.34 / 180;
					        var lat = Math.log(Math.tan((90 + ll.lat) * Math.PI / 360)) / (Math.PI / 180);
					        lat = lat * 20037508.34 / 180;
					    return new OpenLayers.LonLat(lon, lat);
						}
		
				        var lonLat = new lonLatToMercator(new OpenLayers.LonLat(hw,rw));
						var point = new OpenLayers.Geometry.Point(lonLat.lon, lonLat.lat);
						var pointFeature = new OpenLayers.Feature.Vector(point,null,null);
						highlightFeature.addFeatures(pointFeature);
						highlightFeature.redraw();
						
											
						var xy = new OpenLayers.LonLat(hw,rw)
	
						var proj2 = new OpenLayers.Projection("EPSG:4326");
						xy.transform(proj2, map.getProjectionObject());
						map.panTo(xy);
			        };
				}	
		
				//Aufruf für benutzerdefinierte Definition in userScripts.js
				attributeGrid = queryAttributetable(map, layerArray, atr_layer, highlightFeature, null);
				
				//dem attributeGrid wird hier ein selectionModel hinzugefügt 
				 var sm= new Ext.grid.RowSelectionModel({ 
						singleSelect: true,
						listeners: {
							rowselect: {
								fn: function(sm,index,record) {
									connectMap(sm,index,record); 
									
								}
							},
							selectionchange: {
								fn: function(sm,index,record) {
									highlightFeature.destroyFeatures();
								}
							}
						}
					})
		    
			    attributeGrid.selModel = sm;
			
			};
		  
		  if(layerArray[k][0]=='WMS'){
		 	var atr_request = '';
		  	atr_request += layerArray[k][2]+'&SERVICE=WFS&VERSION=1.0.0&REQUEST=getfeature&TYPENAME='+layerArray[k][1];
			attributeGrid = queryAttributetable(map, layerArray, atr_layer, highlightFeature, atr_request);
		  }
		
		}
		
		}
			
		if(Ext.getCmp('attributeWin')){
			if (Ext.getCmp('attributeWin').items.items.length) {
			    Ext.getCmp('attributeWin').remove(Ext.getCmp('attributeWin').items.items[0]);
			}; 
			Ext.getCmp('attributeWin').add({
				items:attributeGrid
			});
			Ext.getCmp('attributeWin').doLayout();
		};
		    //Funktion zum synchronisieren der Ausdehnung des Gridpanels an das Attributfenster
	    function sync(){
			if(Ext.getCmp('attributeWin') && Ext.getCmp('attributeGrid')){
			Ext.getCmp('attributeGrid').setWidth(Ext.getCmp('attributeWin').getWidth()-15);
			Ext.getCmp('attributeGrid').setHeight(Ext.getCmp('attributeWin').getHeight()-34);
			}
		}
		
		sync();
		
		return attributeGrid;
	}

	showAttributetable = function (map, layerArray){
		    	    
		    //Funktion zum synchronisieren der Ausdehnung des Gridpanels an das Attributfenster
		    function sync(){
				if(Ext.getCmp('attributeWin')){
				Ext.getCmp('attributeGrid').setWidth(Ext.getCmp('attributeWin').getWidth()-15);
				Ext.getCmp('attributeGrid').setHeight(Ext.getCmp('attributeWin').getHeight()-34);
				}
			}
		    
			// Erstellen des Attributfensters
			var attributeWin = new Ext.Window({
				id: 'attributeWin',
		        layout: 'fit',
		        title: 'Sachdaten',
		        sizeable: true,
		        width:198,
		        height:257,
		        autoScroll: true,
		        items: initAttributetable(map, layerArray),
		        listeners:{
		        	resize: sync
		        }
			});
			attributeWin.doLayout();
			
			attributeWin.on('close', function() {
	
				map.removeLayer(map.getLayer('highlightFeature'));
		
				if(Ext.getCmp('attribute-btn').pressed == true){
		   			Ext.getCmp('attribute-btn').toggle();
		   		}
			});
			
			attributeWin.show(this);		
	}


	createHtml = function (e, layerName, qryURL){
		if (layerName == 'eisdielen'){
			var req = 
					'<table class="tbl_partner_select" id="querytab">' +
						'<tr><td class="td_partner_select">Eisdiele</td><td>'+ e.feature.attributes["eisdiele"] +'</td></tr>' +
						'<tr><td class="td_partner_select">Anschrift</td><td>'+ e.feature.attributes["strasse"] +'</td></tr>' +
						'<tr><td class="td_partner_select"></td><td>'+ e.feature.attributes["ort"] +'</td></tr>' +
						'<tr><td class="td_partner_select">Telefon</td><td>'+ e.feature.attributes["telefon"] +'</td></tr>' +
						'<tr><td class="td_partner_select">Homepage</td><td><a href=\"http://'+ e.feature.attributes["homepage"] +'\" target=\"_blank\">'+ e.feature.attributes["homepage"] +'</a></td></tr>' +
					'</table>' + '<br/>' +
					'<div style="border-style:groove; border-width:2px; border-color: #ffffff; margin: 3px"><img src="'+ e.feature.attributes["bild"] +'" width="100%" id="abfragebild"/></div>'
			
		    return req;
		}
		if (layerName == 'Kontakt'){
			var req = 
					'<table class="tbl_partner_select" id="querytab">' +
						'<tr><td class="td_partner_select">Einrichtung</td><td>'+ e.feature.attributes["einrichtung"] +'</td></tr>' +
						'<tr><td class="td_partner_select">Ort</td><td>'+ e.feature.attributes["ort"] +'</td></tr>' +
						'<tr><td class="td_partner_select">Land</td><td>'+ e.feature.attributes["land"] +'</td></tr>' +
						'<tr><td class="td_partner_select">Homepage</td><td><a href=\"http://'+ e.feature.attributes["homepage"] +'\" target=\"_blank\">'+ e.feature.attributes["homepage"] +'</a></td></tr>' +
					'</table>' + '<br/>' +
					'<div style="border-style:groove; border-width:2px; border-color: #ffffff; margin: 3px"><img src="'+ e.feature.attributes["bild"] +'" width="100%" id="abfragebild"/></div>'
	
		    return req;
		}else{
					var qrystore = new GeoExt.data.FeatureStore({
				proxy: new GeoExt.data.ProtocolProxy({
		    	           protocol: new OpenLayers.Protocol.HTTP({
							url: qryURL,
		                    format: new OpenLayers.Format.GML()
		                })
		            }),
		            fields: [
			            {name: 'gid', type: 'string'},
			            {name: 'data', type: 'string'},
			            {name: 'einheit', type: 'string'}
			        ],
			        autoLoad: true
				});
				
	 			var gridPanel = new Ext.grid.GridPanel({
			        //title: "Feature Grid",
			        autoHeight: true,
			        store: qrystore,
			        //width: 230,
			        columns: [{
			            header: "ID",
			            width:50,
			            dataIndex: "gid"
			        }, {
			            header: "Wert",
			            width: 100,
			            dataIndex: "data"
			        }, {
			            header: "Einheit",
			            width: 56,
			            dataIndex: "einheit"
			        }]
			    });			            
	
				
				if(Ext.getCmp('queryWindow')){
			  		if (Ext.getCmp('queryWindow').items.items.length) {
					    Ext.getCmp('queryWindow').remove(Ext.getCmp('queryWindow').items.items[0]);
					}; 
					Ext.getCmp('queryWindow').add({
						items:[gridPanel]
			  		});
			  		Ext.getCmp('queryWindow').doLayout();
			  	};
	
	
			return 'hzhzhzhz';
		}
	
	}



//Attributtabelle
	queryAttributetable = function (map, layerArray, atr_layer, highlightFeature, atr_request){
	var url_req;
			for(var k = 0; k < layerArray.length; k++){
			
			if (layerArray[k][5] == true && layerArray[k][4] == true){
				layerName = layerArray[k][1];
						
				if(layerArray[k][0]=='GML'){
					url_req = layerArray[k][2];
				};
				
				if(layerArray[k][0]=='WMS'){
					url_req = atr_request;
				};
		
				//Abfragedefinition für den aktiven Abfragelayer aus layerArray auslesen und dynamisch in den Store und das Grid schreiben
				var fields_arr = new Array();
				var fields_arr2 = new Array();
				var columns_arr = new Array();
				var columns_arr2 = new Array();
	
				for (var z = 0; z < layerArray[k][6].length; z++){
	
					fields_arr[z] = JSON.stringify({name: layerArray[k][6][z][0], type: layerArray[k][6][z][2]});
					fields_arr2[z] = JSON.parse(fields_arr[z]);
					
					columns_arr[z] = JSON.stringify({header: layerArray[k][6][z][1], width: layerArray[k][6][z][3], dataIndex: layerArray[k][6][z][0], sortable: true});
					columns_arr2[z] = JSON.parse(columns_arr[z]);
			
				}	
				
				// create the Data Store
				var attributeStore = new GeoExt.data.FeatureStore({  
					id: 'attributeStore',
					layer: atr_layer,
					proxy: new GeoExt.data.ProtocolProxy({
						protocol: new OpenLayers.Protocol.HTTP({
						url: url_req,
								  format: new OpenLayers.Format.GML()
							   })
					}),
						fields: fields_arr2,
						autoLoad: true   
				});   
	
				
				// Erstellen des Attribut-Gridpanels
				var attributeGrid = new Ext.grid.GridPanel({
		        	store: attributeStore,
		        	id: 'attributeGrid',
			        columns: columns_arr2,
			        width:'100%',
			        height:'100%'
			    });
		    }
		}
	
		return attributeGrid
	}

	popupLayer = function (map, layerArray){		 
		
		var v=location.search.substring(1, location.search.length); 
			
			for(var k = 0; k < layerArray.length; k++){
			
			if (layerArray[k][5] == true && layerArray[k][4] == true){
				layerName = layerArray[k][1];
						
				var allLayers = map.layers;
				var numLayers = map.getNumLayers(); 
				//Reihenfolge der Layer muss neu geordnet werden, so dass highlightFeature-Layer oben liegt
				for(ii= 0; ii<numLayers;ii++){
					if(allLayers[ii].name==layerName){
		
		//Definition des Style Objekts für den Partnerlayer
			var myStyles = new OpenLayers.StyleMap({
		        'default': new OpenLayers.Style({
		            pointRadius: 5, // sized according to type attribute
		            fillColor: "#fffeee",
		            strokeColor: "#ff9933",
		            strokeWidth: 2
		        }),
		        'select': new OpenLayers.Style({
		            fillColor: "#539d05",
		            strokeColor: "#ff5a05"
		        })
		    });
			 
			
		    //Popupfenster für Hover-Event
		    var popup;
	
			function onFeatureSelect(e) {
					popup = new OpenLayers.Popup.AnchoredBubble("chicken", 
		                     e.geometry.getBounds().getCenterLonLat(),
		                     null,
		                     "<div style='font-size:.8em; color:black'>" + e.attributes["einrichtung"] +"</div>",
		                     null, false, null);
		            map.addPopup(popup);
		            popup.setBackgroundColor('rgb(211,225,241)');   
		            popup.setOpacity(0.9);
		            popup.setSize(new OpenLayers.Size(200,50)); 
				
	        };
			 
			// Hover Control
		    hoverCtrl1 = new OpenLayers.Control.SelectFeature(allLayers[ii],
				{hover: true,
				id: 'hoverCtrl1',
				onSelect: function(e) {
				onFeatureSelect(e); 
		        },
		        onUnselect: function() {
		        	popup.destroy();
		        }
			});  
			//map.removeLayer(gispartner);
			
		    map.addControl(hoverCtrl1); 
			hoverCtrl1.activate(); 
					}
				}
			}
		}
	}






// Startvariablen Map
		Ext.getDom('map1').innerHTML = '';
		var zielElement = 'map1';
		var mapName = 'ex_01';
		var maxExtent = f_maxExtent(-20037508.342789244, -20037508.342789244, 20037508.342789244, 20037508.342789244);//(5.3, 47.0, 15.5, 55.5);//(660000, 5800000, 1800000, 7400000)
		var restrictedExtent = f_restrictedExtent(-20037508.342789244, -20037508.342789244, 20037508.342789244, 20037508.342789244);//(1308004, 6463612, 1674245, 6746062);//(5.3, 47.0, 15.5, 55.5);//(660000, 5800000, 1800000, 7400000);//
		var centerMap = f_centerMap(1521109, 6622000, 1543620, 6636278);//(5.3, 47.0, 15.5, 55.5);//(660000, 5800000, 1800000, 7400000);//
		var zoomLevels = 20;
		var startZoom = 12;
		//var minScale = 6000000;
		var mapUnits = 'm';
		var projection = f_projection('EPSG:900913');
		var displayProjection = f_projection('EPSG:900913');
		// Toolbars
		var tbarHidden = false;
		var tbarHeight = 20;
		var bbarHidden = true;
		var bbarHeight = 28;
		var popupHover = false;

var tbarArray = [
	//['Spacer', null],
	//['LayerTree', 'Layerauswahl'],
	//['Attribute', 'Attributtabelle'],
	//['Legend', 'Legende'],
/*	['Spacer', null],
	['Spacer', null],
	['Spacer', null],*/
	['DragPan', 'Verschieben'],
	['ZoomIn', 'Vergrößern'],
	['ZoomOut', 'Verkleinern']
	//['MaxExtent', 'volle Ausdehnung'],
/*	['Spacer', null],
	['Spacer', null],
	['Spacer', null],*/
	//['Query', 'Abfragen'],
	//['Measurement', 'Messwerkzeuge']
/*	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],
	['Spacer', null],*/
	//['Print', 'Drucken'],
	//['Help', 'Hilfe']
];
//Definition der Inhalte für die Bootombar - Name(ScaleLine; MousePosition oder Label), Text, Div-Element(bbarLeft; bbarMid; bbarRight)
var bbarArray = [
	['ScaleLine', 'Maßstab', 'bbarLeft'],
	['MousePosition', 'Koordinaten', 'bbarRight'],
	['Label', 'powered by VisDat', 'bbarMid']
];

//Definition für Attributfenster: Originalbezeichnung, Bezeichnung in der Darstellung, Datentyp, width (für Darstellung), Primärschlüssel(true/false)
var eisdielen = [
	['gid', 'Nr','string', 20, true],
	['eisdiele', 'Eisdiele','string', 160, false]
	
];

// Parameter: Layertyp, Layername, Layer-URL, Legend-URL, abfrageLayer(true/false), aktiver Abfragelayer(true/false), attributeArray, baseLayer (true/false)
var layerArray = [
	//['Google','Google Physical', null, null, false, false, null],
	//['Google','Google Streets', null, null, false, false, null],
	//,['Google','Google Hybrid', null, null]
	['Mapnik', 'OpenStreetMap (Mapnik)', 'http://tile.openstreetmap.org/', 'http://tile.openstreetmap.org/', false, false, null, false],
	['OSM', 'OpenStreetMap', 'http://tah.openstreetmap.org/Tiles/tile/${z}/${x}/${y}.png', null, false, false, null, true]
	//['WMS', 'c', 'http://www.landesvermessung.sachsen.de/ias/basiskarte4/service/SRV4DOPFREE/WMSFREE_TK/WMSFREE_TK/wmsservice?', null, false, false, null, false],	
	//['WMS', 'c', 'http://192.168.0.190/cgi-bin/mapserv?map=/var/www/mapfiles/luftbilder_sachsen.map', null, false, false, null, false],
	//['TMS', 'SachsenLuft', 'http://192.168.0.190/tilecache/tilecache.py/', null, false, false, null, false],
	//['Mapnik', 'SachsenLuft', 'http://192.168.0.190/tilecache/tilecache.py/1.1.1/SachsenLuft/', null, false, false, null, false],
	//['WMS', 'Verkehr', 'http://192.168.0.190/cgi-bin/mapserv?map=/var/www/mapfiles/luftbilder_sachsen.map', 'http://192.168.0.190/cgi-bin/mapserv?map=/var/www/mapfiles/luftbilder_sachsen.map', false, false, null, false]
	//['WMS', 'sehenswuerdigkeiten', 'http://192.168.0.190/cgi-bin/mapserv?map=/var/www/mapfiles/example_01.map', 'http://192.168.0.190/cgi-bin/mapserv?map=/var/www/mapfiles/hoeckendorf2.map', true, false, sehenswuerdigkeiten],
	//['GML', 'eisdielen', 'http://192.168.0.190/visdat/clients/eisdielen_dresden/gis/eisdielen_dresden.xml', null, true, true, eisdielen, false]
	//['GML', 'hauptnutzung', 'http://192.168.0.190/cgi-bin/mapserv?map=/var/www/mapfiles/example_01.map&', 'http://192.168.0.190/cgi-bin/mapserv?map=/var/www/mapfiles/example_01.map&', true, false, null]
];






//Definition für den Layerbaum
var treemodel = [{
	text: 'OpenStreetMap (Mapnik)',
	iconCls: 'hideicon',
    layerName: 'OpenStreetMap (Mapnik)',
    id: 'OpenStreetMap (Mapnik)',
    checked: true
	}];
   
		var selectCtrl;
			
			
		// Definition der Bbar Div-Elemente	
		init();	
		
		var map = buildMap(mapName, zoomLevels, projection, displayProjection, mapUnits, maxExtent, restrictedExtent, centerMap, startZoom);

		buildLayer(map, layerArray, projection);	
		
		var layertree = buildLayerTree(map, treemodel, layerArray);
		
		var tbar = f_tbar(map, tbarHeight, tbarHidden, tbarArray, treemodel, layerArray, layertree);
		var bbar = f_bbar(map, bbarHeight, bbarHidden, bbarArray);
	
		buildLegendPanel(layerArray, layertree);
		
		
		if (popupHover == true){
			popupLayer(map, layerArray);
		};
		
		f_mapPanel(zielElement);
		f_mapComponent(map, tbar, bbar);
		
		map.baseLayer.setVisibility(false);
		map.setCenter(centerPoint, startZoom);
		
		var allLayers = map.layers;
		var numLayers = map.getNumLayers(); 
		
		map.addLayer(ergebnisLayer);
		map.addLayer(centerLayer);
		
				
		
//LayerStyle der Umkreissuche für kleineren Maßstab	
		var umkreisStyles = new OpenLayers.StyleMap({
            'default': new OpenLayers.Style({
                pointRadius: 2, // sized according to type attribute
                 //externalGraphic: "http://192.168.0.190/visdat/clients/galf_partner/images/logo.png",
                fillColor: "blue",//"rgb(214,227,243)",
                fillOpacity: 1,
                strokeColor: "darkblue",
                strokeWidth: 2,
                strokeOpacity: 1
            })
        });

        
        var centerStyles = new OpenLayers.StyleMap({
            'default': new OpenLayers.Style({
                pointRadius: 5, // sized according to type attribute
                 //externalGraphic: "http://192.168.0.190/visdat/clients/galf_partner/images/logo.png",
                fillColor: "ff0000",//"rgb(214,227,243)",
                fillOpacity: 1,
                strokeColor: "8b0000",
                strokeWidth: 2,
                strokeOpacity: 1
            })
        });
        
         var selStyles = new OpenLayers.StyleMap({
            'default': new OpenLayers.Style({
                pointRadius: 5, // sized according to type attribute
                 //externalGraphic: "http://192.168.0.190/visdat/clients/galf_partner/images/logo.png",
                fillColor: "ff0000",//"rgb(214,227,243)",
                fillOpacity: 1,
                strokeColor: "8b0000",
                strokeWidth: 2,
                strokeOpacity: 1
            })
        });
        
//Layer definieren		
		centerLayer.styleMap = centerStyles;
		ergebnisLayer.styleMap = umkreisStyles;
		//map.addLayer(ergebnisLayer);
		//map.addLayer(centerLayer);
		map.zoomToExtent(ergebnisLayer.getDataExtent());
		
		//Selektieren des im GridPanel angeklickten Features	
		var highlightLayer = new OpenLayers.Layer.Vector('highlightLayer');
		highlightLayer.styleMap = selStyles;
		map.addLayer(highlightLayer);

//LayerStyle bei größerem Maßstab		
		if (map.getZoom() > 9){
			var umkreisStylesGross = new OpenLayers.StyleMap({
	            'default': new OpenLayers.Style({
	                pointRadius: 4, // sized according to type attribute
	                 //externalGraphic: "http://192.168.0.190/visdat/clients/galf_partner/images/logo.png",
	                fillColor: "blue",//"rgb(214,227,243)",
	                fillOpacity: 1,
	                strokeColor: "darkblue",
	                strokeWidth: 2,
	                strokeOpacity: 1
	            })
	        });
	       
			var centerStylesGross = new OpenLayers.StyleMap({
	            'default': new OpenLayers.Style({
	                pointRadius: 7, // sized according to type attribute
	                 //externalGraphic: "http://192.168.0.190/visdat/clients/galf_partner/images/logo.png",
	                fillColor: "red",//"rgb(214,227,243)",
	                fillOpacity: 1,
	                strokeColor: "darkred",
	                strokeWidth: 3,
	                strokeOpacity: 1
	            })
        	});
        	
        	var selStylesGross = new OpenLayers.StyleMap({
	            'default': new OpenLayers.Style({
	                pointRadius: 7, // sized according to type attribute
	                 //externalGraphic: "http://192.168.0.190/visdat/clients/galf_partner/images/logo.png",
	                fillColor: "red",//"rgb(214,227,243)",
	                fillOpacity: 1,
	                strokeColor: "darkred",
	                strokeWidth: 3,
	                strokeOpacity: 1
	            })
       	 	});
	        
	        ergebnisLayer.styleMap = umkreisStylesGross;
	        centerLayer.styleMap = centerStylesGross;
	        highlightLayer.styleMap = selStylesGross;
	        ergebnisLayer.redraw();
	        centerLayer.redraw();
	        highlightLayer.redraw();
	        
		}

//highlightLayer mit Feature füllen	
		 Ext.getCmp('results_umkreissuche').addListener('rowclick', function(g,id,rc){
		 	var sModel = Ext.getCmp('results_umkreissuche').getSelectionModel();
		 	var sel = sModel.getSelected();
		 	highlightLayer.destroyFeatures();
			 	
		 	//alert(sel.data.x);
		 	var rw = sel.data.x;
		 	var hw = sel.data.y;
	
				//Koordinatenumrechnung in sphericalMercator
			function lonLatToMercator(ll) {
				var lon = ll.lon * 20037508.34 / 180;
		        var lat = Math.log(Math.tan((90 + ll.lat) * Math.PI / 360)) / (Math.PI / 180);
		        lat = lat * 20037508.34 / 180;
		    return new OpenLayers.LonLat(lon, lat);
			}

		//Layer für die Ergebnisse der Umkreissuche
		    var lonLat = new lonLatToMercator(new OpenLayers.LonLat(rw, hw));
			var point = new OpenLayers.Geometry.Point(lonLat.lon, lonLat.lat);
			var pointFeature = new OpenLayers.Feature.Vector(point,null,null);
			highlightLayer.addFeatures(pointFeature);
			
			//map.addLayer(highlightLayer);

		 });

};