Ext.namespace('geops');

geops.wika = function() {
	
	Ext.QuickTips.init();

	// Globale Varialblen und Funktionen
	var map = null;
	var vectorLayer = null;
	var measuresLayer = null; // Layer für alle Features (unabhängig von Pagination)
	var measurePopup = null;
	var newMeasureId = null; // Tempor�e Ids <= 0 fr die Neuanlage, wird bei jeder neuen Measure dekrementiert
	
	var modObject = null;
	
	var loggedIn = false;
	var user = "";
	var userId = null;
	
	var rootdir = null;
	var menu = null;
	var footer = null;
	var btnLogin = null;
	var btnLogout = null;
	
	var measureRecord = null;
	var dsMeasures = null;
	var dsCategories = null;
	var dsUsers = null;
	var dataViewMeasures = null;
	
	var tplMeasures = null;
	
	//var gridMeasuresInitialized = false;
	var dsMeasuresLoaded = false;
	var dsCategoriesLoaded = false;
	var dsUsersLoaded = false;
	
	var mainaxisRecord = null;
	var dsMainaxes = null;
	var dsMainaxesLoaded = false;
	
	var editModus = false;
	
	// User Controls
	var btnEditModus = null;
	//var mapEditPanel = null;
	var btnFeaturePolygon = null;
	var btnFeatureLine = null;
	var btnFeaturePoint = null;
	var btnFeatureSelect = null;
	var btnKmlImport = null;
	var btnLineMainaxes = null;
	var btnSelectMainaxes = null;
	var btnDeleteMainaxis = null;
	var btnKmlImportMainaxes = null;
	var btnSaveMainaxes = null;
	
	// Feature Modification
	var featureModControls = null;
	var reshapeMoveControl = null;
	var selectFeatControl = null;
	
	// Mainaxes Modification
	var featureModControlsMainaxes = null;
	var selectControlMainaxes = null;
	var reshapeMoveControlMainaxes = null;
	
	// Paging Measures
	var pageLimitMeasures = null;
	
	var sideMenu = null;
	var measurePanel = null; // muss explizit initialisiert werden wg. Problemen mit MS-Combo
	var measurePanelInitialized = null;
	var btnSaveAll = null;
	var layerPanel = null;
	var mainaxesPanel = null;
	var mainaxesPanelInitialized = null;
	var infoPanel = null;
	
	
	var layerSwitcherComp = null;
	
	var form_kmlImport = null;
	var form_kmlImportMainaxes = null;
	
	var currentMainaxisId = null;
	
	var currentPanel = null; // benötigt um auf Events von OL-Controls passend zu reagieren
	
	var currentMainaxis = null; // aktuell selektierte HA, zum Löschen
	
	var btnPopupSave = null;
	
	var switchPanel = function(panel) 
	{
		geops.wika.currentPanel = panel;
		switch(panel)
		{
			case 'measures':
				removeMainaxesControls();
				addMeasureControls();
				break;
			case 'mainaxes':
				removeMeasureControls();
				removeMeasureModifyControl();
				addMainaxesControls();
				geops.wika.vectorLayer.removeFeatures(geops.wika.vectorLayer.features);
				break
			default:
				removeMainaxesControls();
				removeMeasureControls();
				removeMeasureModifyControl();
				break;
		}
	}
	
	var measureValid = function(record)
	{
		if(record.get('name') == '')
			return false;
		if(record.get('category') == '')
			return false;
		return true;
	}
	
	var initLocalizations = function()
	{
		Ext.MessageBox.buttonText.yes = 'Ja';
		Ext.MessageBox.buttonText.no = 'Nein';
		Ext.MessageBox.buttonText.cancel = 'Abbrechen';
		Ext.MessageBox.buttonText.ok = 'OK';
	};
	
	var saveAllMeasures = function()
	{
		var records = geops.wika.dsMeasures.getModifiedRecords();
		for(var i=0; i<records.length; i++)
		{
			saveMeasure(records[i]);
		}
	};
	
	//HACK Trick, damit Inhalt von Accordion Panels im IE bei Aktivierung jedesmal angezeigt wird
	var resizeTrick = function(panel)
	{
		width = geops.wika.sideMenu.getInnerWidth();
		geops.wika.sideMenu.setWidth(width+1);
		geops.wika.sideMenu.setWidth(width);
	};
	
	// Custom Renderers
	var renderDate = function(value){
		return value ? value.format('d.m.Y') : '';
	};
	
	// Im View-Modus Feature deselektieren
	var onPopupClose = function(e,feature,popup)
	{
		if(!geops.wika.editModus)
		{
			geops.wika.selectFeatControl.unselect(feature);
		}
		
		removePopup();
	};
	
	// Popup entfernen, 
	// Markierung im DV entfernen
	// (BUG: Polygon-Punkte noch angezeigt)
	var unselectFeature = function(feature)
	{
		hideMeasurePopup(feature);
		markDvMeasure(0);
	};
	
	// Popup entfernen (wenn Feature unbekannt)
	var removePopup = function()
	{
		if(geops.wika.measurePopup != null)
		{
			geops.wika.map.removePopup(geops.wika.measurePopup);
			geops.wika.measurePopup.destroy();
			geops.wika.measurePopup = null;
		}	
	};
	
	var kmlExport = function(btn)
	{
		var filename = 'massnahmen.kml';
		
		var paramsStr = "?";
		measureParams = geops.wika.dsMeasures.baseParams;
		for(var key in measureParams)
		{
			if(measureParams[key])
			{
				paramsStr += key + "=" + measureParams[key] + "&";
			}
		}
		paramsStr += "filename=" + filename;
		window.open(geops.wika.rootdir + '/measure/kmlexport' + paramsStr, 'blank'); //, 'blank'
	};
	
	var kmlExportMainaxes = function()
	{
		var filename = 'hauptachsen.kml';
		
		params = {
			map_ll: geops.wika.map.getExtent().left + ' ' + geops.wika.map.getExtent().bottom,
			map_ur: geops.wika.map.getExtent().right + ' ' + geops.wika.map.getExtent().top
		};
		
		var paramsStr = "?";
		for(var key in params)
		{
			if(params[key])
			{
				paramsStr += key + "=" + params[key] + "&";
			}
		}
		paramsStr += "filename=" + filename;
		//alert(paramsStr);
		window.open(geops.wika.rootdir + '/mainaxes/kmlexport' + paramsStr, 'blank');
	}
	
	var kmlUpload = function()
	{
		if(Ext.get('field_kml_upload').getValue() != '')
		{
			geops.wika.form_kmlImport.getForm().submit({
				success: function(form, result) {
					json = Ext.util.JSON.decode(result.response.responseText);
					if(json.success)
					{
						win_kmlImport.hide();
					
						kml = new OpenLayers.Format.KML();
						kmlStr = json.kmlstr;
						
						// Trick, da einige Tags bei der Kommunikation mit dem Client verloren gehen
						kmlStr = kmlStr.replace(/_to_/g, '<');
						kmlStr = kmlStr.replace(/_tc_/g, '>');
						
						features = kml.read(kmlStr);
						
						jsonKml = json.jsonKml;
						
						// Features adden und Records erstellen
						//features.each(function(feature){
						for(var i=0; i<features.length; i++)
						{
							coll = new OpenLayers.Geometry.Collection(new Array(features[i].geometry));
							coll.transform(new OpenLayers.Projection("EPSG:4326"), new OpenLayers.Projection("EPSG:900913"));
							
							if(features[i].fid == null) 
							{	
								// zugehöriges ExtendedData-Element: 
								if(features.length == 1)
									extDataEl = jsonKml.kml.Document.Placemark.ExtendedData.Data;
								else
									extDataEl = jsonKml.kml.Document.Placemark[i].ExtendedData.Data;
								
								var visibility = true;
								var date_start = '';
								var date_end = '';
								var category = 'ohne Kategorie';
								if(extDataEl)
								{
									for(var j=0; j<extDataEl.length; j++) // Block funktioniert nicht im IE!!!
									{
										//alert(extDataEl[j].attributes.name);
										switch(extDataEl[j].attributes.name)
										{
											case 'visibility':
												if(extDataEl[j].value == 1)
													visibility = true;
												else
													visibility = false;
												break;
											case 'date_start':
												date_start = extDataEl[j].value;
												break;
											case 'date_end':
												date_end = extDataEl[j].value;
												break;
											case 'category':
												category = extDataEl[j].value;
												break;
											default: // Attribute, die von der Applikation nicht berücksichtigt werden
										}
									}
								}
								
								if(!features[i].attributes.name || (features[i].attributes.name == ''))
								{
									name = 'Bitte Name eingeben';
								}
								else
								{
									name = features[i].attributes.name;
								}
								
								features[i].fid = geops.wika.newMeasureId;
								measure = new geops.wika.measureRecord({
									id: geops.wika.newMeasureId,
									name: '',
									visibility: true,
									wkb_geom: '',
									description: '',
									date_start: '',
									date_end: '',
									category: '',
									user_id: ''
								});
								measure.id = geops.wika.newMeasureId;
								geops.wika.dsMeasures.add(measure);
								geops.wika.newMeasureId--;
								measure.set('wkb_geom', features[i].geometry.toString());
								
								// Change für alle Felder aufrufen
								changeMeasureValue(measure, 'name', name, true);
								changeMeasureValue(measure, 'visibility', visibility, true);
								changeMeasureValue(measure, 'wkb_geom', features[i].geometry, true);
								changeMeasureValue(measure, 'description', features[i].attributes.description, true);
								changeMeasureValue(measure, 'date_start', date_start, true);
								changeMeasureValue(measure, 'date_end', date_end, true);
								changeMeasureValue(measure, 'category', category, true);
							}
						}
						geops.wika.vectorLayer.addFeatures(features);
					}
					else
					{
						Ext.Msg.show({
						title: 'Fehler',
						msg: 'Fehler beim Lesen der KML-Datei',
						buttons: Ext.Msg.OK
						});
					}
				},
				failure: function() {
					Ext.Msg.show({
					title: 'Fehler',
					msg: 'Fehler beim Lesen der KML-Datei',
					buttons: Ext.Msg.OK
					});
				}
			});
		}
		else
		{
			Ext.Msg.show({
			title: 'Hinweis',
			msg: 'Bitte w&auml;hlen Sie eine Datei aus',
			buttons: Ext.Msg.OK
			});
		}
	};
	
	
	
	
	
	var kmlUploadMainaxes = function()
	{
		if(Ext.get('field_kml_upload_mainaxes').getValue() != '')
		{
			geops.wika.form_kmlImportMainaxes.getForm().submit({
				success: function(form, result) {
					json = Ext.util.JSON.decode(result.response.responseText);
					if(json.success)
					{
						win_kmlImport.hide();
					
						kml = new OpenLayers.Format.KML();
						kmlStr = json.kmlstr;
						
						// Trick, da einige Tags bei der Kommunikation mit dem Client verloren gehen
						kmlStr = kmlStr.replace(/_to_/g, '<');
						kmlStr = kmlStr.replace(/_tc_/g, '>');
						
						features = kml.read(kmlStr);
						
						jsonKml = json.jsonKml;
						
						// Features adden und Records erstellen
						//features.each(function(feature){
						for(var i=0; i<features.length; i++)
						{
							// korrekte Transformation, wenn es sich um eine Collection handelt:
							features[i].geometry.transform(new OpenLayers.Projection("EPSG:4326"), new OpenLayers.Projection("EPSG:900913")); 
							//OpenLayers.Projection.transform(features[i].geometry.components[0], new OpenLayers.Projection("EPSG:4326"), new OpenLayers.Projection("EPSG:900913"));
							
							if(features[i].fid == null) 
							{	
								features[i].fid = geops.wika.currentMainaxisId;
								mainaxis = new geops.wika.mainaxisRecord({
									gid: geops.wika.currentMainaxisId,
									wkb_geom: ''
								});
								mainaxis.id = geops.wika.currentMainaxisId;
								geops.wika.dsMainaxes.add(mainaxis);
								geops.wika.currentMainaxisId--;
								mainaxis.set('wkb_geom', features[i].geometry.toString());
							}
						}
						geops.wika.vectorLayer.addFeatures(features);
						if(features.length > 0)
						{
							geops.wika.btnSaveMainaxes.setDisabled(false);
						}
					}
					else
					{
						Ext.Msg.show({
						title: 'Fehler',
						msg: 'Fehler beim Lesen der KML-Datei',
						buttons: Ext.Msg.OK
						});
					}
				},
				failure: function() {
					Ext.Msg.show({
					title: 'Fehler',
					msg: 'Fehler beim Lesen der KML-Datei',
					buttons: Ext.Msg.OK
					});
				}
			});
		}
		else
		{
			Ext.Msg.show({
			title: 'Hinweis',
			msg: 'Bitte w&auml;hlen Sie eine Datei aus',
			buttons: Ext.Msg.OK
			});
		}
	};
	
	
	
	
	
	var kmlImport = function(btn)
	{
		geops.wika.form_kmlImport = new Ext.FormPanel({
			labelWidth: 60, 
			frame: true,
			bodyStyle: 'padding:5px 5px 0',
			width: 350,
			height: 150,
			fileUpload: true,
			//standardSubmit: true,
			url: geops.wika.rootdir + '/measure/kmlimport',
			method: 'post',
			items: [
				new Ext.form.TextField({
					fieldLabel: 'KML-Datei',
					id: 'field_kml_upload',
					inputType: 'file'
				})
			],
			buttons: [
				{
					text: 'Daten importieren',
					type: 'submit',
					handler: function() {kmlUpload();}
				},
				{
					text: 'Abbrechen',
					handler: function(){win_kmlImport.hide();}
				}
			]
		});
		
		
		win_kmlImport = new Ext.Window({
			title: 'KML-Datei importieren',
			layout: 'fit',
			width:350,
			height:150,
			closeAction: 'hide',
			plain: true,
			modal: true,
			keys: [
				    {
				        key: [10,13],
				        fn: kmlUpload
				    }
			],
			items: [geops.wika.form_kmlImport]
		});
		
		win_kmlImport.show(this);
	};


	var kmlImportMainaxes = function(btn)
	{
		geops.wika.form_kmlImportMainaxes = new Ext.FormPanel({
			labelWidth: 60, 
			frame: true,
			bodyStyle: 'padding:5px 5px 0',
			width: 350,
			height: 150,
			fileUpload: true,
			//standardSubmit: true,
			url: geops.wika.rootdir + '/mainaxes/kmlimport',
			method: 'post',
			items: [
				new Ext.form.TextField({
					fieldLabel: 'KML-Datei',
					id: 'field_kml_upload_mainaxes',
					inputType: 'file'
				})
			],
			buttons: [
				{
					text: 'Daten importieren',
					type: 'submit',
					handler: function() {kmlUploadMainaxes();}
				},
				{
					text: 'Abbrechen',
					handler: function(){win_kmlImport.hide();}
				}
			]
		});
		
		win_kmlImport = new Ext.Window({
			title: 'KML-Datei importieren',
			layout: 'fit',
			width:350,
			height:150,
			closeAction: 'hide',
			plain: true,
			modal: true,
			keys: [
				    {
				        key: [10,13],
				        fn: kmlUploadMainaxes
				    }
			],
			items: [geops.wika.form_kmlImportMainaxes]
		});
		
		win_kmlImport.show(this);
	};

	var markDvMeasure = function(id)
	{
		els = $$('div.box_measure');
		els.each(function(el){el.removeClassName('active');});
		if($('dv_measure_' + id))
			$('dv_measure_' + id).addClassName('active');
	};
	
	var selectMeasure = function(dataView, index, htmlEl, evt)
	{
		var featureId = dataView.store.getAt(index).get('id');
		for(var i=0; i<geops.wika.vectorLayer.features.length; ++i) 
		{
			if(geops.wika.vectorLayer.features[i].fid == featureId) 
			{
				feature = geops.wika.vectorLayer.features[i];
				break;
			}
		}
		if(feature)
		{
			// Aktuelles Feature selektieren
			if(geops.wika.editModus) // Im Editmodus mssen Punkt zum Verschieben / verformen angezeigt werden
			{
				// Workaround: Neue OL-Version benötigt für den Aufruf ModifyFeature->selectFeature() keinen Feature-Parameter mehr, sondern
				// ein Objekt welches ein Feature-Attribut besitzt. (nicht-öffentliche Funktion, es soll ein Mausklick auf Feature
				// simuliert werden)
				dummy = new Object();
				dummy.feature = feature;
				if(geops.wika.reshapeMoveControl)
				{
					geops.wika.reshapeMoveControl.selectFeature(dummy);
				}
			}
			else
			{
				geops.wika.selectFeatControl.unselectAll();
				geops.wika.selectFeatControl.select(feature); // BUG: hierbei erscheinen auch Punkte zum Verschieben! (Grund: modFeatureControl->onModificationStart wird ausgelöst! warum? wird Mausklick simuliert?)
			}
		}
	};
	
	var enableAddMainaxis = function(enable)
	{
		if(enable)
		{
			geops.wika.featureModControlsMainaxes['line'].activate();
		}
		else
		{
			geops.wika.featureModControlsMainaxes['line'].deactivate();
		}
	};
	
	
	var switchFeatureEditModus = function(type)
	{
		for(var key in geops.wika.featureModControls) 
		{
			geops.wika.featureModControls[key].deactivate();
		}
		
		if(type == 'polygon')
		{
			geops.wika.featureModControls['polygon'].activate();
		}
		else if(type == 'line')
		{
			geops.wika.featureModControls['line'].activate();
		}
		else if(type == 'point')
		{
			geops.wika.featureModControls['point'].activate();
		}
	};
	
	
	var deleteMeasure = function(record)
	{
		Ext.Msg.show({
			title: 'Warnung',
			msg: 'Ma&szlig;nahme wirklich l&ouml;schen?',
			buttons: Ext.Msg.YESNO,
			fn: function(id){
	 	   		if(id=="yes")
	 	   		{
	 	   			Ext.Ajax.request({
						waitMsg: 'L&ouml;schen...',
						url: geops.wika.rootdir + '/measure/deletemeasure',
						params: {id: record.get('id')},
						failure: function(response,options){
							Ext.MessageBox.alert('Fehler','Kommunikation mit Server nicht m&ouml;glich');
						},                       
						success: function(response,options){
							json = Ext.util.JSON.decode(response.responseText);
							if(json.success)
							{
								oldId = record.get('id');
								geops.wika.dsMeasures.remove(record);
								
								var feature = null;
						        for(var i=0; i<geops.wika.vectorLayer.features.length; ++i) 
						        {
						            if(geops.wika.vectorLayer.features[i].fid == oldId) 
						            {
						                feature = geops.wika.vectorLayer.features[i];
						                break;
						            }
						        }
						        hideMeasurePopup(feature);
						        geops.wika.vectorLayer.destroyFeatures(new Array(feature));
						        geops.wika.selectFeatControl.unselect(feature); // reicht aus, um Punkte zu entfernen!? (Betrifft eigentlich reshapeMoveControl!)
						        return true;
							}
							else
							{
								Ext.Msg.show({
									title: 'Fehler',
									msg: 'Ma&szlig;nahme konnte nicht gel&ouml;scht werden.',
									buttons: Ext.Msg.OK
								});
								return false;
							}
						}
					});
	    		}
	    	}
       	});
	};
	
	// Entfernen Maßnahme/Feature das nur Client-seitig exisitiert
	var deleteMeasureOnClient = function(record)
	{
		Ext.Msg.show({
			title: 'Warnung',
			msg: 'Ma&szlig;nahme wirklich l&ouml;schen?',
			buttons: Ext.Msg.YESNO,
			fn: function(id){
	 	   		if(id=="yes")
	 	   		{
	 	   			oldId = record.get('id');
					geops.wika.dsMeasures.remove(record);
					
					var feature = null;
			        for(var i=0; i<geops.wika.vectorLayer.features.length; ++i) 
			        {
			            if(geops.wika.vectorLayer.features[i].fid == oldId) 
			            {
			                feature = geops.wika.vectorLayer.features[i];
			                break;
			            }
			        }
			        hideMeasurePopup(feature);
			        geops.wika.vectorLayer.destroyFeatures(new Array(feature));
			        geops.wika.selectFeatControl.unselect(feature); // reicht aus, um Punkte zu entfernen!? (Betrifft eigentlich reshapeMoveControl!)
			        return true;
				}
	    	}
       	});
	};

	var switchEditModus = function(btn, pressed)
	{
		if(pressed)
		{
			// ModifyFeatureControl initialisieren (hier, damit es nur im EditModus existiert, sonst werden Verschiebepunkte wegen Konflikt mit SelectFeatureControl auch im View-Modus angezeigt)
			addMeasureModifyControl();
			
			geops.wika.editModus = true;
			geops.wika.btnFeaturePolygon.setDisabled(false);
			geops.wika.btnFeatureLine.setDisabled(false);
			geops.wika.btnFeaturePoint.setDisabled(false);
			geops.wika.btnFeatureSelect.setDisabled(false);
			geops.wika.reshapeMoveControl.activate();
			geops.wika.btnKmlImport.setDisabled(false);
		}
		else
		{
			// ModifyFeatureControl zerstören
			if(geops.wika.reshapeMoveControl)
				geops.wika.reshapeMoveControl.destroy();
		
			geops.wika.editModus = false;
			geops.wika.btnFeaturePolygon.setDisabled(true);
			geops.wika.btnFeatureLine.setDisabled(true);
			geops.wika.btnFeaturePoint.setDisabled(true);
			geops.wika.btnFeatureSelect.setDisabled(true);
			geops.wika.btnKmlImport.setDisabled(true);
		}
	};
	
	var changeMainaxis = function(gid, wkb_geom)
	{
		var axis = geops.wika.dsMainaxes.getById(gid);
		if(axis)
			axis.set('wkb_geom', wkb_geom);
	}
	
	var addMainaxis = function(feature)
	{
		// TODO
		//alert('add');
		geops.wika.currentMainaxisId--;
		feature.fid = geops.wika.currentMainaxisId;
		
		axis = new geops.wika.mainaxisRecord({
			id: geops.wika.currentMainaxisId,
			gid: geops.wika.currentMainaxisId,
			wkb_geom: ''
		});
		axis.id = geops.wika.currentMainaxisId;
		geops.wika.dsMainaxes.add(axis);
		axis.set('wkb_geom', feature.geometry);
	}
	
	var saveMainaxes = function()
	{
		// changes im DS
		var changedMainaxes = geops.wika.dsMainaxes.getModifiedRecords();
		changedMainaxes.each(function(axis){
			// Extjs-Bug: Es befinden sich auch Records in Modified, die nicht mehr im DS selber vorhanden sind!
			//exist = geops.wika.dsMainaxes.indexOf(axis);
			saveMainaxis(axis);//axis.get('gid'), axis.get('wkb_geom'));
		});
		if(changedMainaxes.size() == 0)
		{
			geops.wika.btnSaveMainaxes.setDisabled(true);
		}
		geops.wika.btnDeleteMainaxis.setDisabled(true);
	};
	
	var saveMainaxis = function(record)
	{
		//alert(record.get('gid'));
		//alert(record.get('wkb_geom'));
		id = record.get('gid');
		wkb_geom = "" + record.get('wkb_geom');
	
		var request = Ext.Ajax.request({
			waitMsg: 'Speichern...',
			url: geops.wika.rootdir + '/mainaxes/savemainaxes',
			params: {id: id, wkb_geom: wkb_geom},
			failure: function(response,options){
				Ext.MessageBox.alert('Fehler','Kommunikation mit Server nicht m&ouml;glich');
			},                       
			success: function(response,options){
				json = Ext.util.JSON.decode(response.responseText);
				//alert(json);
				if(json.success)
				{
					geops.wika.btnSaveMainaxes.setDisabled(true);
					record.commit();
					//geops.wika.dsMainaxes.reload();
					updateMainaxes();
					return true;
				}
				else
				{
					Ext.Msg.show({
						title: 'Fehler',
						msg: '&Auml;nderungen konnten nicht gespeichert werden.',
						buttons: Ext.Msg.OK
					});
					return false;
				}
			}
		});
	};
	
	var deleteMainaxis = function()
	{
		if(geops.wika.currentMainaxis)
		{
			Ext.Msg.show({
				title: 'Warnung',
				msg: 'Hauptachse wirklich l&ouml;schen?',
				buttons: Ext.Msg.YESNO,
				fn: function(id){
		 	   		if(id=="yes")
		 	   		{
		 	   			if(geops.wika.currentMainaxis.fid > 0)
		 	   			{
		 	   				Ext.Ajax.request({
								waitMsg: 'L&ouml;schen...',
								url: geops.wika.rootdir + '/mainaxes/deletemainaxes',
								params: {id: geops.wika.currentMainaxis.fid},
								failure: function(response,options){
									Ext.MessageBox.alert('Fehler','Kommunikation mit Server nicht m&ouml;glich');
								},                       
								success: function(response,options){
									json = Ext.util.JSON.decode(response.responseText);
									if(json.success)
									{
										geops.wika.vectorLayer.destroyFeatures(new Array(geops.wika.currentMainaxis));
						        		geops.wika.selectControlMainaxes.unselect(geops.wika.currentMainaxis);
						        		//geops.wika.dsMainaxes.reload(); // schlägt manchmal fehl!
						        		updateMainaxes();
						        		geops.wika.btnDeleteMainaxis.setDisabled(true);
						        		geops.wika.currentMainaxis = null;
										return true;
									}
									else
									{
										Ext.Msg.show({
											title: 'Fehler',
											msg: 'Hauptachse konnte nicht gel&ouml;scht werden.',
											buttons: Ext.Msg.OK
										});
										return false;
									}
								}
							});
						}
						else // nur client-seitiges Löschen
						{
							deleteRec = geops.wika.dsMainaxes.getById(geops.wika.currentMainaxis.fid);
							deleteRec.commit(); // ist sonst noch in ModifiedRecords vorhanden!
							geops.wika.dsMainaxes.remove(deleteRec);
						    geops.wika.btnDeleteMainaxis.setDisabled(true);
						    geops.wika.vectorLayer.destroyFeatures(new Array(geops.wika.currentMainaxis));
							geops.wika.selectControlMainaxes.unselect(geops.wika.currentMainaxis);
							geops.wika.currentMainaxis = null;
						    return true;
						}
					}
		    	}
	       	});
	     }
	};

	var saveMeasure = function(record, evt)
	{
		// Event hier stoppen, da sonst ebenfalls Select-Evt auf DataView ausgeführt wird
		if(evt)
			evt.stopPropagation();
	
		var measureParams = record.getChanges();
		measureParams.id = record.get('id');
		
		//var success = false;
		
		var request = Ext.Ajax.request({
			waitMsg: 'Speichern...',
			url: geops.wika.rootdir + '/measure/savemeasure',
			params: measureParams,
			failure: function(response,options){
				Ext.MessageBox.alert('Fehler','Kommunikation mit Server nicht m&ouml;glich');
			},                       
			success: function(response,options){
				json = Ext.util.JSON.decode(response.responseText);
				if(json.success)
				{
					oldId = record.get('id'); // Nicht mehr benötigt, wenn DataStore neu geladen wird
					var feature = null;
			        for(var i=0; i<geops.wika.vectorLayer.features.length; ++i) 
			        {
			            if(geops.wika.vectorLayer.features[i].fid == oldId) 
			            {
			                feature = geops.wika.vectorLayer.features[i];
			                break;
			            }
			        }
				
					if(json.newId) // Neuanlage erfolgt: Id für Record und Feature neu setzen
					{
						record.set('id', json.newId);
						record.id = json.newId;
						
						record.set('user_id', geops.wika.userId);
						
						// notwendig, damit Measure existiert und erneut selektiert werden kann!
						geops.wika.dsMeasures.remove(record);
						geops.wika.dsMeasures.add(record);
						
						feature.fid = json.newId;
					}
					
					
					geops.wika.selectFeatControl.unselect(feature); // Bug: Punkte noch angezeigt
					record.commit();
					//geops.wika.checkModifiedRecords();
					
					// Checken, ob noch ungespeicherte Measures existieren, falls nein, save-all-Button disabled setzen.
					// Über Rückgabe true/false nicht möglich wg. Scope, Schreiben in Variable innerhalb saveMeasure 
					// nicht möglich wg. asynchronem Verhalten
					var records = geops.wika.dsMeasures.getModifiedRecords();
					if(records.length == 0)
					{
						geops.wika.btnSaveAll.setDisabled(true);
					}
					
					// DataStore neu laden (gewährleistet, dass über Pagination immer alle Maßnahmen erreichbar sind)
					return true;
				}
				else
				{
					Ext.Msg.show({
						title: 'Fehler',
						msg: 'Ma&szlig;nahme konnte nicht gespeichert werden.',
						buttons: Ext.Msg.OK
					});
					return false;
				}
			}
		});
	};

	
	var updateMeasures = function(formPanel)
	{
		var values = formPanel.getForm().getValues();
		
		
		geops.wika.dsMeasures.baseParams = {
			name: values['filter_measure_name'],
			category_ids: Ext.get('filter_measure_category_hidden').getValue(),
			user_ids: Ext.get('filter_measure_user_hidden').getValue(),
			date_start: values['filter_measure_date_from'],
			date_end: values['filter_measure_date_to'],
			map_rectangle: values['filter_measure_map_rectangle'],
			map_ll: geops.wika.map.getExtent().left + ' ' + geops.wika.map.getExtent().bottom,
			map_ur: geops.wika.map.getExtent().right + ' ' + geops.wika.map.getExtent().top
		};
		
		removePopup();
		geops.wika.dsMeasures.load({params:{start:0, limit:geops.wika.pageLimitMeasures}});
	};

	var loginWindow = function()
	{
		var form_login = new Ext.FormPanel({
		labelWidth: 60, 
		frame: true,
		bodyStyle: 'padding:5px 5px 0',
		width: 250,
		height: 150,
		items: [
			{
				html: '<div id="err_login_window" class="msg_error" style="float:left;">&nbsp;</div><div id="msg_login_window" style="display: none"><img src="' + geops.wika.rootdir + '/html/images/loading.gif" />&nbsp;Bitte warten...</div>'
			},
			fieldLogin = new Ext.form.TextField({
				fieldLabel: 'Login',
				name: 'username',
				id: 'field_login_username'
			}),
			fieldPassword = new Ext.form.TextField({
				fieldLabel: 'Passwort',
				name: 'password',
				id: 'field_login_password',
				inputType: 'password'
			})
		],
        
		buttons: [
			btnLogin = new Ext.Button({
			text: 'Anmelden',
			type: 'submit',
			handler: function() {login();}
			}),
			{
				text: 'Abbrechen',
				handler: function(){win_login.hide();}
			}]
		});
		
		
		win_login = new Ext.Window({
			title: 'Login',
			layout: 'fit',
			width:250,
			height:150,
			closeAction: 'hide',
			plain: true,
			modal: true,
			keys: [
				    {
				        key: [10,13],
				        fn: login
				    }
			],
			items: [form_login]
		});
		
		win_login.show(this);
		
		fieldLogin.focus(); // funktioniert nicht korrekt (Focus nur kurz) (mit alerts ok)
	};
	
	var login = function()
	{
		var username = Ext.get('field_login_username').getValue();
		var password = Ext.get('field_login_password').getValue();
		
		conn = new Ext.data.Connection();
		
		conn.on('beforerequest', function(conn, options){
			el = Ext.get('msg_login_window');
			el.setStyle('display', 'inline');
		});
		conn.on('requestcomplete', function(conn, response, options){
			el = Ext.get('msg_login_window');
			el.setStyle('display', 'none');
		});
		
		conn.request({
			url: geops.wika.rootdir + '/auth/login',
			params: { 
				username: username,
				password: password
			},
			failure: function(response,options){
				Ext.MessageBox.alert('Fehler','Kommunikation mit Server nicht möglich');
			},                       
			success: function(response,options){
				json = Ext.util.JSON.decode(response.responseText);
				if(json.success)
				{
					geops.wika.loggedIn = true;
					if(json.user)
					{
						geops.wika.user = json.user;
					}
					if(json.userId)
					{
						geops.wika.userId = json.userId;
					}
					win_login.close();
					updateFooter();
					geops.wika.btnLogin.setDisabled(true);
					geops.wika.btnLogout.setDisabled(false);
					enableUserControls();
					checkMainaxesControls();
					
					// add mainaxesPanel
					geops.wika.mainaxesPanel = new Ext.Panel({
						baseCls: 'ext_panel_accordion',
						title: 'Hauptachsen',
						autoHeight: true
					});
					geops.wika.sideMenu.add(geops.wika.mainaxesPanel);
					resizeTrick();
					geops.wika.mainaxesPanel.on('expand', function(panel){resizeTrick(panel);initMainaxesPanelElements();switchPanel('mainaxes');});
					
				}
				else
				{
					Ext.get('err_login_window').dom.innerHTML = "Login oder Passwort falsch";
				}
			}
		})
	};

	var enableUserControls = function()
	{
		geops.wika.btnEditModus.setDisabled(false);
	}
	
	var checkMainaxesControls = function()
	{
		if(geops.wika.btnLineMainaxes)
		{
			geops.wika.btnLineMainaxes.setDisabled(false);
			geops.wika.btnSelectMainaxes.setDisabled(false);
			geops.wika.btnKmlImportMainaxes.setDisabled(false);
		}
	}
	
	var logout = function()
	{
		window.location.href = geops.wika.rootdir + '/auth/logout';
	};
	
	
	var updateMainaxes = function()
	{
		var ll = geops.wika.map.getExtent().left + ' ' + geops.wika.map.getExtent().bottom;
		var ur = geops.wika.map.getExtent().right + ' ' + geops.wika.map.getExtent().top;
		
		geops.wika.dsMainaxes.baseParams = {
			map_ll: ll,
			map_ur: ur
		};
		
		// Workaround: neu angelegte HAs bei Update nicht mehr angezeigt, aber noch existent
		newAxes = geops.wika.dsMainaxes.getModifiedRecords();
		newAxes.each(function(axis){
			axis.commit();
		}); 
		geops.wika.btnSaveMainaxes.setDisabled(true);
		
		geops.wika.dsMainaxes.load();
	}
	
	var initMainaxesPanelElements = function()
	{
		if(!geops.wika.mainaxesPanelInitialized)
		{
			var btnUpdateMainaxes = new Ext.Button({
				cls:  "x-btn-icon",
				id: 'btn_update_mainaxes',
				icon: geops.wika.rootdir + "/html/images/reload.png",
				tooltip: "Hauptachsen zum Bearbeiten laden",
				handler: function() {updateMainaxes();}
				//type: 'submit'
	    	});
	    	
	    	geops.wika.btnLineMainaxes = new Ext.Button({
				cls:  "x-btn-icon",
				id: "btn_mainaxis_line",
				icon: geops.wika.rootdir + "/html/images/line_active.png",
				tooltip: "neue Hauptachse erfassen",
				disabled: !geops.wika.loggedIn,
				handler: function(btn){enableAddMainaxis(true);},
				enableToggle: true,
				toggleGroup: 'grp_mod_feature'
			});
			
			geops.wika.btnSelectMainaxes = new Ext.Button({
				cls:  "x-btn-icon",
				id: "btn_mainaxis_select",
				icon: geops.wika.rootdir + "/html/images/select_active.png",
				tooltip: "Selektionsmodus",
				disabled: !geops.wika.loggedIn,
				handler: function(btn){enableAddMainaxis(false);},
				enableToggle: true,
				toggleGroup: 'grp_mod_feature',
				pressed: true
			});
			
			geops.wika.btnDeleteMainaxis = new Ext.Button({
				cls:  "x-btn-icon",
				id: "btn_mainaxis_delete",
				icon: geops.wika.rootdir + "/html/images/delete.gif",
				tooltip: "Selektierte Hauptachse l&ouml;schen",
				disabled: true,
				handler: function(btn){deleteMainaxis();},
				enableToggle: true,
				toggleGroup: 'grp_mod_feature',
				pressed: true
			});
			
			geops.wika.btnSaveMainaxes = new Ext.Button({
				id: 'btn_save_mainaxes',
				handler: function() {saveMainaxes();},
				disabled: true,
				type: 'submit',
				text: 'Speichern'
			});
			
			emptyEl = new Ext.Panel({
    			baseCls: 'ext_panel_accordion',
    			border: false,
   				html: '<br/>'
   			});
   			
			
			tbEditMainaxes = new Ext.Toolbar({
   			items: [
   				btnUpdateMainaxes,
   				geops.wika.btnLineMainaxes,
   				geops.wika.btnSelectMainaxes,
   				geops.wika.btnDeleteMainaxis,
   				geops.wika.btnSaveMainaxes
   				]
   			}),
   			
   			emptyEl2 = new Ext.Panel({
    			baseCls: 'ext_panel_accordion',
    			border: false,
   				html: '<br/>'
   			});
   			
   			btnKmlExportMainaxes = new Ext.Button({
   				cls:  "x-btn-text-icon",
				icon: geops.wika.rootdir + "/html/images/kml.png",
				id: "btn_kml_export",
				text: "KML Export",
				tooltip: "Hauptachsen in KML-Datei speichern",
				handler: kmlExportMainaxes
			});
			
			geops.wika.btnKmlImportMainaxes = new Ext.Button({
				id: "btn_kml_import",
				text: "KML Import",
				disabled: !geops.wika.loggedIn,
				tooltip: "Hauptachsen aus KML-Datei in Karte laden",
				handler: kmlImportMainaxes
			});
	    	
			
			tbKmlMainaxes = new Ext.Toolbar({
			items: [
				btnKmlExportMainaxes,
				geops.wika.btnKmlImportMainaxes	
			]
			});
	    	
	    	//geops.wika.mainaxesPanel.add(btnUpdateMainaxes);
	    	//geops.wika.mainaxesPanel.add(emptyEl);
	    	geops.wika.mainaxesPanel.add(tbEditMainaxes);
	    	geops.wika.mainaxesPanel.add(emptyEl2);
	    	geops.wika.mainaxesPanel.add(tbKmlMainaxes);
	    	
	    	
	    	geops.wika.mainaxesPanel.doLayout();
		}
		geops.wika.mainaxesPanelInitialized = true;
	};
	
	// Suchformular erst beim (ersten) Expand initialisieren, da das MultiSelect-Element
	// ansonsten nicht korrekt dargestellt wird
	// (Anm.: gesamtes Panel initialisieren statt einzelner Element ungünstig,
	// da z.B. editButton abhängig von Login, muss daher schon vorher bekannt sein) 
	var initMeasurePanelElements = function()
	{
		if(!geops.wika.measurePanelInitialized)
		{
			var formMeasuresSearch = new Ext.form.FormPanel({
   			title: 'Suche',
   			bodyStyle:'padding:5px 5px 5px 5px',
   			frame: true,
   			collapsible: true,
   			items: [
   				new Ext.form.TextField({
   				fieldLabel: 'Bezeichnung',
   				name: 'filter_measure_name',
   				width: 140
   				}),
   				
    			new Ext.ux.Andrie.Select({
						fieldLabel:'Kategorie',
						multiSelect:true,
						minLength:0,
						store: geops.wika.dsCategories,
						displayField: 'name',
						//valueField: 'name',
						valueField: 'id',
						triggerAction:'all',
						width: 140,
						id: 'filter_measure_category',
						name: 'filter_measure_category',
						hiddenName: 'filter_measure_category_hidden'
					}),
					
				new Ext.ux.Andrie.Select({
						fieldLabel:'Erfasser',
						multiSelect:true,
						minLength:0,
						store: geops.wika.dsUsers,
						displayField: 'username',
						//valueField: 'username',
						valueField: 'id',
						triggerAction:'all',
						width: 140,
						id: 'filter_measure_user',
						name: 'filter_measure_user',
						hiddenName: 'filter_measure_user_hidden'
					}),
				
    				//new Ext.ux.form.XDateField({
    				new Ext.form.DateField({
    					//xtype: 'xdatefield',
						format: 'Y-m-d',
						//renderer: Ext.util.Format.dateRenderer('d.m.Y'),
						renderer: renderDate,
						fieldLabel: 'von',
						name: 'filter_measure_date_from',
						//id: 'filter_measure_date_from', // muss vorhanden sein und gleichen Wert haben wie name-Field, damit Komponente im IE funktioniert
						width: 100
					}),
					//new Ext.ux.form.XDateField({
						new Ext.form.DateField({
						//xtype: 'xdatefield',
						format: 'Y-m-d',
						//renderer: Ext.util.Format.dateRenderer('d.m.Y'),
						renderer: renderDate,
						fieldLabel: 'bis',
						name: 'filter_measure_date_to',
						//id: 'filter_measure_date_to', // muss vorhanden sein und gleichen Wert haben wie name-Field, damit Komponente im IE funktioniert
						width: 100
					}),
					new Ext.form.Checkbox({
			    		boxLabel: 'nur aktueller Kartenausschnitt',
			    		hideLabel: true,
						checked: true,
						name: 'filter_measure_map_rectangle'
						//width: 250
			    	}),
					new Ext.Button({
						id: 'btn_update_measures',
						handler: function(formPanel) {updateMeasures(formMeasuresSearch);},
						type: 'submit',
						text: 'Suche starten'
			    	})
			    	
    		]});
    		
    		
    		geops.wika.tplMeasures = new Ext.XTemplate(
	    	'<tpl for=".">',
	    		'<div class="details_measure">',
		    		'<div style="position: relative;" class="box_measure" id="dv_measure_{id}">',
		    			'<b>{name}</b>&nbsp;({category})',
			    		'<tpl if="date_start && date_end">',
			    			'&nbsp;&nbsp;&nbsp;{date_start} - {date_end}<br/>',
			    		'</tpl>',
			    		'<tpl if="date_start && !date_end">',
			    			'&nbsp;&nbsp;&nbsp;Start: {date_start}<br/>',
			    		'</tpl>',
			    		'<tpl if="!date_start && date_end">',
			    			'&nbsp;&nbsp;&nbsp;Ende: {date_end}<br/>',
			    		'</tpl>',
			    		'<tpl if="this.hasChanged(id)">',
	            			'<span style="float: left">{description}</span>',
	        			'</tpl>',
	        			'<span id="btn_save_measure_{id}" style="position: absolute; right: 0; top: 0; float: right;"></span>',
	        			'<div style="clear: both;"></div>',
        			'</div>',
	    		'</div>',
	    	'</tpl>',
	    	{
	    		hasChanged: function(id){
	    			record = geops.wika.dsMeasures.getById(id);
	    			if(record && record.modified)
	    			{
	    				//$('dv_measure_' + id).addClassName('active');
	    				return true;
	    			}
	    			return false;
     			}
	    	});
	    	
	    	
	    	
	    	geops.wika.dataViewMeasures = new Ext.DataView({
		        store: geops.wika.dsMeasures,
		        tpl: geops.wika.tplMeasures,
		        autoHeight:true,
		        itemSelector: 'div.details_measure'
		        //overClass:'x-view-over',
	    	});
	    	
	    	geops.wika.dataViewMeasures.on('click', selectMeasure);
	    	
	    	emptyEl = new Ext.Panel({
    			baseCls: 'ext_panel_accordion',
    			border: false,
   				html: '<br/>'
   			});
   			
   			geops.wika.btnSaveAll = new Ext.Button({
   				text: 'alle speichern',
   				style: 'padding: 5px 5px 5px 5px',
   				disabled: true,
   				handler: saveAllMeasures
   			});
   			
   			panelSearchResults = new Ext.Panel({
   				title: 'Ma&szlig;nahmen',
   				items: [
   					geops.wika.dataViewMeasures,
   					geops.wika.btnSaveAll,
   					new Ext.PagingToolbar({
   						pageSize: 10,
            			store: geops.wika.dsMeasures
   					})
   				]
   			});
		    
		    geops.wika.btnFeaturePolygon = new Ext.Button({
				cls:  "x-btn-icon",
				id: "btn_feature_polygon",
				icon: geops.wika.rootdir + "/html/images/polygon_active.png",
				tooltip: "neues Polygon erfassen",
				disabled: true,
				handler: function(btn){switchFeatureEditModus('polygon');},
				enableToggle: true,
				toggleGroup: 'grp_mod_feature'
			});
			
			geops.wika.btnFeatureLine = new Ext.Button({
				cls:  "x-btn-icon",
				id: "btn_feature_line",
				icon: geops.wika.rootdir + "/html/images/line_active.png",
				tooltip: "neue Linie erfassen",
				disabled: true,
				handler: function(btn){switchFeatureEditModus('line');},
				enableToggle: true,
				toggleGroup: 'grp_mod_feature'
			});
			
			geops.wika.btnFeaturePoint = new Ext.Button({
				cls:  "x-btn-icon",
				id: "btn_feature_point",
				icon: geops.wika.rootdir + "/html/images/point_active.png",
				tooltip: "neuen Punkt erfassen",
				disabled: true,
				handler: function(btn){switchFeatureEditModus('point');},
				enableToggle: true,
				toggleGroup: 'grp_mod_feature'
			});
			
			geops.wika.btnFeatureSelect = new Ext.Button({
				cls:  "x-btn-icon",
				id: "btn_feature_select",
				icon: geops.wika.rootdir + "/html/images/select_active.png",
				tooltip: "Selektionsmodus",
				disabled: true,
				handler: function(btn){switchFeatureEditModus('select');},
				enableToggle: true,
				toggleGroup: 'grp_mod_feature',
				pressed: true
			});
			
			emptyEl2 = new Ext.Panel({
    			baseCls: 'ext_panel_accordion',
    			border: false,
   				html: '<br/>'
   			});
   			
			
			tbFeatureEdit = new Ext.Toolbar({
   			items: [
   				geops.wika.btnEditModus,
   				geops.wika.btnFeaturePolygon,
   				geops.wika.btnFeatureLine,
   				geops.wika.btnFeaturePoint,
   				geops.wika.btnFeatureSelect
   				]
   			}),
   			
   			emptyEl3 = new Ext.Panel({
    			baseCls: 'ext_panel_accordion',
    			border: false,
   				html: '<br/>'
   			});
   			
   			btnKmlExport = new Ext.Button({
   				cls:  "x-btn-text-icon",
				icon: geops.wika.rootdir + "/html/images/kml.png",
				id: "btn_kml_export",
				text: "KML Export",
				tooltip: "Ma&szlig;nahmen in KML-Datei speichern",
				handler: kmlExport
			});
			
			geops.wika.btnKmlImport = new Ext.Button({
				id: "btn_kml_import",
				text: "KML Import",
				disabled: true,
				tooltip: "KML-Daten aus Datei in Karte laden",
				handler: kmlImport
			});
	    	
			
			tbKml = new Ext.Toolbar({
			items: [
				btnKmlExport,
				geops.wika.btnKmlImport	
			]
			});
			
			
			geops.wika.measurePanel.add(formMeasuresSearch);
			geops.wika.measurePanel.add(emptyEl);
			geops.wika.measurePanel.add(panelSearchResults);
			geops.wika.measurePanel.add(emptyEl2);
			geops.wika.measurePanel.add(tbFeatureEdit);
			geops.wika.measurePanel.add(emptyEl3);
			geops.wika.measurePanel.add(tbKml);
			
			//formMeasureSearch.doLayout();
			geops.wika.measurePanel.doLayout();
    		
			geops.wika.measurePanelInitialized = true;
			
			geops.wika.dsMeasures.load({params:{start:0, limit:geops.wika.pageLimitMeasures}});
		}
	};

	var initLayout = function()
	{
		// Formular in eigener Funktion initialisiert, erst bei Aufruf des Panels im Accordion, da sonst
		// Bug mit Multiple Select Control
	
		geops.wika.btnEditModus = new Ext.Button({
    		text: "Bearbeiten",
    		enableToggle: true,
    		disabled: true,
    		tooltip: "Wechseln in Bearbeitungs-Modus"
		});
		geops.wika.btnEditModus.on('toggle', switchEditModus);
		
		geops.wika.layerSwitcherComp = new geops.ol.LayerSwitcher({map: geops.wika.map});
		
		
			var viewport = new Ext.Viewport({
			layout:'border',
			items:[ // BorderLayout.Region
			{ 
				region:'north',
				contentEl: 'north',
				height:50
			},
			{
				region:'south',
				contentEl: 'south',
				height:5
			},
			geops.wika.sideMenu = new Ext.Panel({
				//labelWidth: 60,
				region: 'west',
				split: true,
				width: 300,
				title: '&nbsp;',
				collapsible: true,
				baseCls: 'ext_panel_accordion',
				layout:'accordion',
				
				//bodyStyle:'overflow:visible!important;', // IE TEST
				
   				defaults: {
       				bodyStyle: 'padding:15px'
       				//bodyStyle: 'padding:15px;overflow:visible;zoom:normal;' // IE TEST
   				},
   				layoutConfig: {
					titleCollapse: false,
					animate: true,
					activeOnTop: true
   				},
   				items: [
					
					geops.wika.infoPanel = new Ext.Panel({
						baseCls: 'ext_panel_accordion',
						title: 'Informationen',
						autoHeight: true,
						html: '<img style="padding-bottom: 30px; float: left;" src="' + geops.wika.rootdir + '/html/images/logo_wildkatze.gif" width="120" height="48" alt="Rettungsnetz Wildkatze" title="Wildkatze">' +
								'<img style="float: right;" src="' + geops.wika.rootdir + '/html/images/logo_bund.gif" width="120" height="37" alt="BUND" title="BUND">' +
								'<div style="clear: both;"></div>' +
								'<p>Seit 2004 koordiniert der BUND Th&uuml;ringen das &quot;Rettungsnetz f&uuml;r die Wildkatze&quot; - ein Projekt, das sich den l&auml;nder&uuml;bergreifenden Verbund von Wildkatzenlebensr&auml;umen auf die Fahnen geschrieben hat. geOps liefert dazu eine Webmapping-Applikation, die den aktuellen Stand des Netzes darstellt und sich als Kommunikationsplattform zwischen den betroffenen Interessengruppen etablieren soll.</p>'
						//bodyStyle: 'padding:5px 5px 0',
					}),
					geops.wika.layerPanel = new Ext.Panel({
						baseCls: 'ext_panel_accordion',
						title: 'Kartenlayer',
						autoHeight: true,
						items: [
							geops.wika.layerSwitcherComp
						]
					}),
					geops.wika.measurePanel = new Ext.Panel({
						baseCls: 'ext_panel_accordion',
						title: 'Ma&szlig;nahmen',
						autoHeight: true
					})
					/*geops.wika.mainaxesPanel = new Ext.Panel({
						baseCls: 'ext_panel_accordion',
						title: 'Hauptachsen',
						autoHeight: true
					})*/
		    		]
			}),
			{
				region:'east',
				contentEl: 'east'
			},
			{
				region:'center',
				contentEl: 'center'
			}]
		});
		
		geops.wika.sideMenu.on('collapse', function(panel){geops.wika.map.updateSize();});
		geops.wika.sideMenu.on('expand', function(panel){geops.wika.map.updateSize();});
		geops.wika.sideMenu.on('resize', function(panel){geops.wika.map.updateSize();});
		
		// Expand registrieren, weil Panel mit MS-Combo nicht vorher initialisiert sein darf!
		geops.wika.measurePanel.on('expand', function(panel){resizeTrick(panel);initMeasurePanelElements();switchPanel('measures');});
		geops.wika.layerPanel.on('expand', function(panel){resizeTrick(panel);switchPanel('layers');});
		geops.wika.infoPanel.on('expand', function(panel){resizeTrick(panel);switchPanel('info');});
		
		geops.wika.layerSwitcherComp.expandOverlayTree();
	};

	var initMap = function()
	{
		var bounds = new OpenLayers.Bounds(0,6000000,2200000,7300000);
		
		var options = {
      		projection: "EPSG:900913",
      		//displayProjection: new OpenLayers.Projection("EPSG:4326"), // hat Probleme im IE erzeugt
      		displayProjection: "EPSG:4326",
      		units: "m",
	  		maxResolution:156543.0339,
	  		minResolution: 0.29858214168548586,
	  		numZoomLevels:20,
      		maxExtent: bounds,
      		//maxExtent: new OpenLayers.Bounds(-20037508, -20037508,20037508, 20037508.34),
			controls: []
  		};
  		geops.wika.map = new OpenLayers.Map('map', options);
  		
  		var googlesatelliteLayer = new OpenLayers.Layer.Google("Satellitenbild" , {'sphericalMercator': true, type: G_SATELLITE_MAP, minZoomLevel: 0, maxZoomLevel: 17 });
		googlesatelliteLayer.addOptions({legendSrc:'http://www.geops.de/wika/img/google_satellite.gif'});
		geops.wika.map.addLayer(googlesatelliteLayer);
		
		var googleLayer = new OpenLayers.Layer.Google("Landkarte", { 'sphericalMercator': true, minZoomLevel: 0, maxZoomLevel: 17});
		googleLayer.addOptions({legendSrc:'http://www.geops.de/wika/img/google_map.gif'});
		geops.wika.map.addLayer(googleLayer);
		
		var googlehybridLayer = new OpenLayers.Layer.Google("Satellitenbildkarte" , {'sphericalMercator': true, type: G_HYBRID_MAP, minZoomLevel: 0, maxZoomLevel: 17 });
		googlehybridLayer.addOptions({legendSrc:'http://www.geops.de/wika/img/google_hybrid.gif'});
		geops.wika.map.addLayer(googlehybridLayer);
		
		
		
		var korridorLayer =  new OpenLayers.Layer.WMS( 'Wegeplan Wildkatze Deutschland',
			["http://sd1.geops.de/tiles?",
				"http://sd2.geops.de/tiles?",
				"http://sd3.geops.de/tiles?",
				"http://sd4.geops.de/tiles?",
				"http://sd5.geops.de/tiles"],
			{'layers': 'Korridor',
				transparent: true, 
				format: 'image/gif'},																						 
			{'reproject': false,							 
				'opacity': 0.4,
				'isBaseLayer': false,
				'wrapDateLine': true,
				visibility: false,
				maxResolution:156543.0339,
				minResolution: 0.29858214168548586,
				numZoomLevels:20
				//'reproject': true				
			});
		korridorLayer.addOptions({legendSrc:'http://www.geops.de/cgi-bin/wika.wms?Service=WMS&Version=1.1.1&Request=GetLegendGraphic&Layer=Korridor1&Format=image/gif'});
		geops.wika.map.addLayer(korridorLayer);
		
		// Erzeugt Fehler beim Umschalten Basis-Layer
		var habitatLayer = new OpenLayers.Layer.WMS.Untiled( 'Geeignete Wildkatzen-Lebensr&auml;ume ab 500qkm Gr&ouml;&szlig;e',
			["http://sd1.geops.de/cgi-bin/wika.wms?",
				"http://sd2.geops.de/cgi-bin/wika.wms?",
				"http://sd3.geops.de/cgi-bin/wika.wms?",
				"http://sd4.geops.de/cgi-bin/wika.wms?",
				"http://sd5.geops.de/cgi-bin/wika.wms?"],
			{'layers': 'Habitat',
				transparent: true, 
				format: 'image/gif'},																						 
			{'reproject': false,
				'isBaseLayer': false,
				'wrapDateLine': true,
				visibility: false,
				maxResolution:156543.0339,
				minResolution: 0.29858214168548586,
				numZoomLevels:20											 
			});
		habitatLayer.addOptions({legendSrc:'http://www.geops.de/cgi-bin/wika.wms?Service=WMS&Version=1.1.1&Request=GetLegendGraphic&Layer=Habitat&Format=image/gif'});
		geops.wika.map.addLayer(habitatLayer);
		
		var mainaxesLayer = new OpenLayers.Layer.WMS( 'Hauptachsen des Wegeplans Wildkatze',
			["http://sd1.geops.de/tiles",
				"http://sd2.geops.de/tiles?",
				"http://sd3.geops.de/tiles?",
				"http://sd4.geops.de/tiles?",
				"http://sd5.geops.de/tiles?"],
			{'layers': 'Hauptachsen',
				transparent: true, 
				format: 'image/gif'},																						 
			{'reproject': false,
				'isBaseLayer': false,
				'wrapDateLine': true,
				maxResolution:156543.0339,
				minResolution: 0.29858214168548586,
				numZoomLevels:20											 
			});
		mainaxesLayer.addOptions({legendSrc:'http://www.geops.de/wika/img/mainaxes.gif'});
		geops.wika.map.addLayer(mainaxesLayer);
		
		// Erzeugt Fehler beim Umschalten Basis-Layer
		var startpunkteLayer = new OpenLayers.Layer.WMS.Untiled( 'Wildkatzenvorkommen - Startpunkte f&uuml;r Korridormodellierung',
			["http://sd1.geops.de/cgi-bin/wika.wms?",
				"http://sd2.geops.de/cgi-bin/wika.wms?",
				"http://sd3.geops.de/cgi-bin/wika.wms?",
				"http://sd4.geops.de/cgi-bin/wika.wms?",
				"http://sd5.geops.de/cgi-bin/wika.wms?"],
			{'layers': 'Startpunkte',
				transparent: true, 
				format: 'image/gif'},																						 
			{'reproject': false,
				'isBaseLayer': false,
				'wrapDateLine': true,
				visibility: false,
				maxResolution:156543.0339,
				minResolution: 0.29858214168548586,
				numZoomLevels:20											 
			});
		startpunkteLayer.addOptions({legendSrc:'http://www.geops.de/cgi-bin/wika.wms?Service=WMS&Version=1.1.1&Request=GetLegendGraphic&Layer=Startpunkte&Format=image/gif'});
		geops.wika.map.addLayer(startpunkteLayer);
		
		// Erzeugt Fehler beim Umschalten Basis-Layer
		var endpunkteLayer = new OpenLayers.Layer.WMS.Untiled( 'Zielpunkte f&uuml;r Korridormodellierung',
			["http://sd1.geops.de/cgi-bin/wika.wms?",
				"http://sd2.geops.de/cgi-bin/wika.wms?",
				"http://sd3.geops.de/cgi-bin/wika.wms?",
				"http://sd4.geops.de/cgi-bin/wika.wms?",
				"http://sd5.geops.de/cgi-bin/wika.wms?"],
			{'layers': 'Endpunkte',
				transparent: true, 
				format: 'image/gif'},																						 
			{'reproject': false,
				'isBaseLayer': false,
				'wrapDateLine': true,
				visibility: false,
				maxResolution:156543.0339,
				minResolution: 0.29858214168548586,
				numZoomLevels:20											 
			});
		endpunkteLayer.addOptions({legendSrc:'http://www.geops.de/cgi-bin/wika.wms?Service=WMS&Version=1.1.1&Request=GetLegendGraphic&Layer=Endpunkte&Format=image/gif'});
		geops.wika.map.addLayer(endpunkteLayer);
		
		var featureStyle = OpenLayers.Util.applyDefaults({ 
             strokeWidth: 3 
         }, OpenLayers.Feature.Vector.style['default']); 
		
		
		geops.wika.vectorLayer = new OpenLayers.Layer.Vector("Suchergebnisse aktuelle Seite", {
			isBaseLayer: false, 
			displayInLayerSwitcher: false,
			style: featureStyle
			});
        	geops.wika.map.addLayer(geops.wika.vectorLayer);
        	
        // Layer für alle Maßnahmen die mit Suche übereinstimmten (unabhängig von Pagination)
        geops.wika.measureLayer = new OpenLayers.Layer.Vector("Ma&szlig;nahmen", {isBaseLayer: false});
        
		geops.wika.map.addControl(new OpenLayers.Control.MouseDefaults());
		geops.wika.map.addControl(new OpenLayers.Control.ArgParser());
		geops.wika.map.addControl(new OpenLayers.Control.PanZoomBar());
		
		geops.wika.map.zoomToMaxExtent();
		
		OpenLayers.IMAGE_RELOAD_ATTEMPTS = 5;
		OpenLayers.Util.onImageLoadErrorColor = "transparent";
	};
	
	var addMeasureControls = function()
	{
		geops.wika.featureModControls = {
                point: new OpenLayers.Control.DrawFeature(geops.wika.vectorLayer,
                            OpenLayers.Handler.Point, {featureAdded: function(feature){
                            	if(geops.wika.currentPanel == 'measures')
                            		showMeasurePopup(feature);
                            }}),
                line: new OpenLayers.Control.DrawFeature(geops.wika.vectorLayer,
                            OpenLayers.Handler.Path, {featureAdded: function(feature){
                            	if(geops.wika.currentPanel == 'measures')
                            		showMeasurePopup(feature);
                            	}}),
                polygon: new OpenLayers.Control.DrawFeature(geops.wika.vectorLayer,
                            OpenLayers.Handler.Polygon, {featureAdded: function(feature){
                            	if(geops.wika.currentPanel == 'measures')
                            		showMeasurePopup(feature);
                            	}})
            };
            
        for(var key in geops.wika.featureModControls) 
		{
			// Zurückschalten in Select-Modus, wenn Feature erstellt (sonst wird bei Click weiteres Feature erstellt)
			geops.wika.featureModControls[key].featureAdded = function(feature){
				if(geops.wika.currentPanel == 'measures')
				{
					geops.wika.btnFeatureSelect.toggle(true);
					switchFeatureEditModus('select');
					showMeasurePopup(feature);
				}
			};
		
			geops.wika.map.addControl(geops.wika.featureModControls[key]);
		}
        
		geops.wika.selectFeatControl = new OpenLayers.Control.SelectFeature(geops.wika.vectorLayer, {toggle:true});	
		geops.wika.map.addControl(geops.wika.selectFeatControl);
		geops.wika.selectFeatControl.onSelect = function(feature)
		{
			if(geops.wika.currentPanel == 'measures')
			{
				showMeasurePopup(feature);
			}
		}
		geops.wika.selectFeatControl.onUnselect = function(feature)
		{
			if(geops.wika.currentPanel == 'measures')
			{
				unselectFeature(feature);
			}
		}	
		geops.wika.selectFeatControl.activate(); 
		
	}
	
	var removeMeasureControls = function()
	{
		if(geops.wika.selectFeatControl)
			geops.wika.selectFeatControl.destroy();
		if(geops.wika.featureModControls)
		{
			for(var key in geops.wika.featureModControls) 
			{
				geops.wika.map.removeControl(geops.wika.featureModControls[key]);
			}
		}
	}
	
	var addMeasureModifyControl = function()
	{
		geops.wika.reshapeMoveControl = new OpenLayers.Control.ModifyFeature(geops.wika.vectorLayer, {});
			geops.wika.reshapeMoveControl.mode |= OpenLayers.Control.ModifyFeature.RESHAPE|OpenLayers.Control.ModifyFeature.DRAG;
			geops.wika.reshapeMoveControl.onModificationStart = function(feature)
			{
				if(geops.wika.currentPanel == 'measures')
				{
					showMeasurePopup(feature);
				}
			};
	
			geops.wika.reshapeMoveControl.onModification = function(feature){
				if(geops.wika.currentPanel == 'measures')
				{
					hideMeasurePopup(feature);
					
					if(feature.fid != null)
					{
						var measureRecord = geops.wika.dsMeasures.getById(feature.fid);
						if(geops.wika.editModus)
						{
							changeMeasureValue(measureRecord, 'wkb_geom', feature.geometry.toString());
							geops.wika.modObject = null;
						}
					}
				}
			};
			
			geops.wika.reshapeMoveControl.onModificationEnd = function(feature){
				if(geops.wika.currentPanel == 'measures')
				{
					if(feature.fid != null)
					{
						unselectFeature(feature);
					}
				}
			};
			geops.wika.map.addControl(geops.wika.reshapeMoveControl);
	};
	
	var removeMeasureModifyControl = function()
	{
		if(geops.wika.reshapeMoveControl)
		{
			geops.wika.reshapeMoveControl.destroy();
		}
	}
	
	var addMainaxesControls = function()
	{
		geops.wika.featureModControlsMainaxes = {
             line: new OpenLayers.Control.DrawFeature(geops.wika.vectorLayer,
                         OpenLayers.Handler.Path, {featureAdded: function(feature){addMainaxis(feature);geops.wika.btnSaveMainaxes.setDisabled(false);}})
             
        };
        geops.wika.map.addControl(geops.wika.featureModControlsMainaxes['line']);
         
        geops.wika.selectControlMainaxes = new OpenLayers.Control.SelectFeature(geops.wika.vectorLayer, {toggle:true});	
		geops.wika.map.addControl(geops.wika.selectControlMainaxes);
		geops.wika.selectControlMainaxes.onSelect = function(feature)
		{
			if(geops.wika.currentPanel == 'mainaxes')
			{
				geops.wika.btnDeleteMainaxis.setDisabled(false);
				geops.wika.currentMainaxis = feature;
				selectMainaxis();
			}
		}
		geops.wika.selectControlMainaxes.onUnselect = function(feature)
		{
			if(geops.wika.currentPanel == 'mainaxes')
			{
				geops.wika.btnDeleteMainaxis.setDisabled(true);
				geops.wika.currentMainaxis = null;
			}
		}
		geops.wika.selectControlMainaxes.activate();
		
		geops.wika.reshapeMoveControlMainaxes = new OpenLayers.Control.ModifyFeature(geops.wika.vectorLayer, {});
		geops.wika.reshapeMoveControlMainaxes.mode |= OpenLayers.Control.ModifyFeature.RESHAPE|OpenLayers.Control.ModifyFeature.DRAG;
		
		geops.wika.reshapeMoveControlMainaxes.onModificationStart = function(feature){}
		geops.wika.reshapeMoveControlMainaxes.onModification = function(feature){
			if(geops.wika.currentPanel == 'mainaxes')
			{
				changeMainaxis(feature.fid, feature.geometry);
				geops.wika.btnSaveMainaxes.setDisabled(false);
			}
		}
		
		geops.wika.reshapeMoveControlMainaxes.onModificationEnd = function(feature){
			
		};
		geops.wika.map.addControl(geops.wika.reshapeMoveControlMainaxes);
	}
	
	var removeMainaxesControls = function()
	{
		if(geops.wika.featureModControlsMainaxes)
			geops.wika.featureModControlsMainaxes['line'].destroy();
		if(geops.wika.selectControlMainaxes)
			geops.wika.selectControlMainaxes.destroy();
		if(geops.wika.reshapeMoveControlMainaxes)
			geops.wika.reshapeMoveControlMainaxes.destroy();
	}
	

	var selectMainaxis = function()
	{
		//alert('select');
	};

	var changeMeasureValue = function(record, name, value, noMark){
		geops.wika.btnSaveAll.setDisabled(false);
		record.set(name, value);
		recordId = record.get('id');
		container = Ext.get('btn_save_measure_' + recordId);
		if(container.dom.innerHTML == "")
		{
			btnSave = new Ext.Button({
				text: 'Speichern',
				renderTo: 'btn_save_measure_' + recordId
				//handler: function(target){if(saveMeasure(record)){target.destroy();}},
			});
			
			btnSave.on('click', function(btn,evt){
					if(saveMeasure(record, evt))
					{
						target.destroy();
					}
				});
				
			// Checken, ob Pflichtfelder eingetragen, sonst Button disablen (darstellen trotzdem, damit ersichtlich ist dass Änderungen erfolgt sind)
			if(!measureValid(record))
			{
				btnSave.setDisabled(true);
			}
			else
			{
				btnSave.setDisabled(false);
			}

			if(!noMark)
			{			
				$('dv_measure_' + recordId).addClassName('active'); // da Template neu gerendert wird erneut auf active setzen
			}
		}
  	};
	
	var showMeasurePopup = function(feature, position)
	{
	 	hideMeasurePopup();
	
		if(geops.wika.editModus)
		{
			if(feature.fid == null) 
			{
				feature.fid = geops.wika.newMeasureId;
				measure = new geops.wika.measureRecord({
					id: geops.wika.newMeasureId,
					name: '',
					visibility: true,
					wkb_geom: '',
					description: '',
					date_start: '',
					date_end: '',
					category: ''
				});
				measure.id = geops.wika.newMeasureId;
				geops.wika.dsMeasures.add(measure);
				geops.wika.newMeasureId--;
				measure.set('wkb_geom', feature.geometry.toString());
			}
			
			measure = geops.wika.dsMeasures.getById(feature.fid);
			
			//if(measure.get('user_id') == geops.wika.userId || feature.fid <= 0) // Löschen-Button bei übereinstimmender UserID oder bei aktuell selbst-angelegten (nur client-seitig existierenden) Maßnahmen
			// temporär darf jeder löschen (weil Möglichkeit besteht, dass Benutzer gelöscht werden, nicht aber Maßnahmen)
				htmlDeleteBtn = '<div id="btn_delete_measure" style="height: 30px;"></div>';
			/*else
				htmlDeleteBtn = '<div style="height: 30px;">&nbsp;</div>';*/
			
			html = '<div id="form_popup_measure" style="width: 270px; height: 250px; padding-top: 20px; padding-right: 10px; margin-bottom: 10px;"></div>' + 
					'<div id ="btn_save_measure" style="height: 30px; float:left;"></div>' +
					htmlDeleteBtn;
		}
		else // View-Modus
		{
			measure = geops.wika.dsMeasures.getById(feature.fid);
			
			
			if(geops.wika.dsUsers.getById(measure.get('user_id')))
			{
  			var creator = geops.wika.dsUsers.getById(measure.get('user_id')).get('username');
  		}
  		else
  		{
  		  var creator = "";
      }
			
			var dateRow = '';
			if(measure.get('date_start') && measure.get('date_end'))
			{
				dateRow = '<div class="row">Zeitraum: ' + measure.get('date_start') + ' - ' + measure.get('date_end') + '</div>';
			}
			else if(measure.get('date_start'))
			{
				dateRow = '<div class="row">Start: ' + measure.get('date_start') + '</div>';
			}
			else if(measure.get('date_end'))
			{
				dateRow = '<div class="row">Ende: ' + measure.get('date_end') + '</div>';
			}
			
			var descRow = '';	
			if(measure.get('description'))
			{
				descRow = '<div class="row description">' + measure.get('description') + '</div>';
			}
			
			html = '<div class="popup_measure" style="padding: 20px 10px 10px 20px; width: 250px;">' +
				'<h1>' + measure.get('name') + '</h1>' +
				'<div class="row">' + measure.get('category') + '</div>' +
				'' + dateRow +
				'' + descRow +
				'<div class="row"><div class="label">Erfasser:</div><div class="value">' + creator + '</div></div>' + 
				'</div>';
				
		}

		feature.popupClass = OpenLayers.Popup.FramedCloud;
		geops.wika.measurePopup = new OpenLayers.Popup.FramedCloud(
			"Ma&szlig;nahme", 
			feature.geometry.getBounds().getCenterLonLat(),
			null,
			html,
			null,
			true,
			function(e){onPopupClose(e,feature,this);}
		);
		feature.popup = geops.wika.measurePopup;
		
		geops.wika.map.addPopup(feature.popup); // Container im Popup muss im DOM vorhanden sein damit ExtJS Formular einfügen kann (deshalb auch feste Größe im Editmodus notwendig)
		
   		if(geops.wika.editModus)
   		{
   			var textFieldName = new Ext.form.TextField({
	 			fieldLabel: 'Bezeichnung',
				width: 150,
				value: measure.get('name'),
				allowBlank: false
			});
	   		textFieldName.on('change', function(evt, value, oldValue){
	   			changeMeasureValue(measure, 'name', value);
	   		});
	   		
	   		var comboBoxCategory = new Ext.form.ComboBox({
				fieldLabel: 'Kategorie',
				editable: false,
				store: geops.wika.dsCategories,
				displayField: 'name',
				//valueField: 'id',
				valueField: 'name',
				width: 150,
				value: measure.get('category'),
				typeAhead: true,
				lazyRender: true,
				triggerAction: 'all',
				forceSelection: true
			});
			comboBoxCategory.on('select', function(target){
			//comboBoxCategory.on('change', function(evt, value, oldValue){ // Bug, funktioniert nur, wenn alert drin! (Focus-Problem, ExtJs Bug)
				changeMeasureValue(measure, 'category', target.value);
				geops.wika.btnPopupSave.setDisabled(false);
	   		});
	   		
	   		var dateFieldStart = new Ext.form.DateField({
				format: 'j.n.Y', // Format ohne führende Nullen (notwendig, da aktuell so aus DB geholt)
				//renderer: Ext.util.Format.dateRenderer('d.m.Y'),
				fieldLabel: 'Beginn',
				width: 100,
				value: measure.get('date_start') // BUG: wird nicht eingetragen obwohl vorhanden!
			});
			dateFieldStart.on('change', function(evt, value){
				//changeMeasureValue(measure, 'date_start', new Date(value).format('d/m/Y'));
				date = new Date(value).format('d.m.Y');
				if(date.indexOf('NaN') >= 0)
					date = '';
				//changeMeasureValue(measure, 'date_start', new Date(value).format('d.m.Y'));
				changeMeasureValue(measure, 'date_start', date);
			});
			
			
			var dateFieldEnd = new Ext.form.DateField({
				format: 'j.n.Y',
				//renderer: Ext.util.Format.dateRenderer('d.m.Y'),
				fieldLabel: 'Ende',
				width: 100,
				value: measure.get('date_end')
			});
			dateFieldEnd.on('change', function(evt, value){
				//changeMeasureValue(measure, 'date_end', new Date(value).format('d/m/Y'));
				date = new Date(value).format('d.m.Y');
				if(date.indexOf('NaN') >= 0)
					date = '';
				//changeMeasureValue(measure, 'date_end', new Date(value).format('d.m.Y'));
				changeMeasureValue(measure, 'date_end', date);
			});
				
	   		var textAreaDescription = new Ext.form.TextArea({
				fieldLabel: 'Beschreibung',
				height: 80,
				width: 150,
				value: measure.get('description')
			});
			textAreaDescription.on('change', function(evt, value){
				changeMeasureValue(measure, 'description', value);
			});
			
			var checkBoxVisibility = new Ext.form.Checkbox({
				fieldLabel: 'allen anzeigen',
				checked: measure.get('visibility')
			});
			checkBoxVisibility.on('change', function(evt, value){
				changeMeasureValue(measure, 'visibility', value);
			});
			
			geops.wika.btnPopupSave = new Ext.Button({
				text: 'Ma&szlig;nahme speichern',
				disabled: true,
				handler: function(target)
				{
					saveMeasure(measure)
				},
				renderTo: 'btn_save_measure'
			});
			
			if(comboBoxCategory.value)
			{
			 geops.wika.btnPopupSave.setDisabled(false);
      }
			
			//if(measure.get('user_id') == geops.wika.userId) // temporär darf jeder löschen, weil sonst Maßnahmen, wo zugehörige Ersteller gelöscht wurden nicht mehr gelöscht werden könnten 
			{
				var btnDelete = new Ext.Button({
					text: 'Ma&szlig;nahme l&ouml;schen',
					handler: function(target){
						deleteMeasure(measure)
					},
					renderTo: 'btn_delete_measure'
				});
			}
			
			var formItems = [
	   				textFieldName,
	   				comboBoxCategory,
	   				dateFieldStart,
	   				dateFieldEnd,
					textAreaDescription,
					checkBoxVisibility
	    	];
	    	
			var formPopupMeasure = new Ext.form.FormPanel({
	   			//title: 'Ma&szlig;nahme bearbeiten',
	   			bodyStyle:'padding:5px 5px 5px 5px',
	   			labelWidth: 100,
	   			frame: false,
	   			border: false,
	   			renderTo: 'form_popup_measure',
	   			//monitorValid: true,
	   			id: 'form_edit_measure',
	   			items: formItems
	    		});
	    		
	    	// Client-seitiges Löschen
	    	if(feature.fid <= 0) 
			{
				var btnDelete = new Ext.Button({
					text: 'Ma&szlig;nahme l&ouml;schen',
					handler: function(target){
						deleteMeasureOnClient(measure);
					},
					renderTo: 'btn_delete_measure'
				});
			}
	    		
	  }
		
		markDvMeasure(feature.fid);
	};


	var hideMeasurePopup = function(feature)
	{
		if(geops.wika.measurePopup != null)
		{
			geops.wika.map.removePopup(geops.wika.measurePopup);
			geops.wika.measurePopup.destroy();
			geops.wika.measurePopup = null;
		}
	};

	var initToolbar = function()
	{
		var tb = new Ext.Toolbar({height:100,'style':'padding-left:15px'});
		tb.render('toolbar');
		
		geops.wika.btnLogin = new Ext.Button({
			id: 'btn_logout',
			handler: loginWindow,
			text: 'Login',
			disabled: geops.wika.loggedIn
			//type: 'submit'
		});
		tb.addField(geops.wika.btnLogin);
		
		geops.wika.btnLogout = new Ext.Button({
			id: 'btn_logout',
			handler: logout,
			text: 'Logout',
			disabled: !geops.wika.loggedIn
		});
		tb.addField(geops.wika.btnLogout);
		
		loginInfo = new Ext.Panel({
			border: false,
			html: '<span style="padding-left: 20px; color: #808080;">(Einloggen mit guest/guest)</span>',
			baseCls: "x-item"
		});
		
		if(geops.wika.user.length > 0)
			loginInfo.html='<span style="padding-left: 20px; color: #808080;">Eingeloggt als: ' + geops.wika.user+'</span>';
		else
			loginInfo.html='<span style="padding-left: 20px; color: #808080;">Nicht angemeldet</span>';
			
		tb.addField(loginInfo);
	};
	
	var initFooter = function()
	{
		footer = new Ext.Toolbar({height:5});
		footer.render('footer');
	};
	
	var updateFooter = function()
	{
		if(geops.wika.user.length > 0)
			loginInfo.html='<span style="padding-left: 20px; color: #808080;">Eingeloggt als: ' + geops.wika.user+'</span>';
		else
			loginInfo.html='<span style="padding-left: 20px; color: #808080;">Nicht angemeldet</span>';
	};
	
	var initData = function()
	{
		geops.wika.newMeasureId = 0;
		geops.wika.currentMainaxisId = 0;
	
		geops.wika.measureRecord = Ext.data.Record.create([
			{name: 'id', type: 'int'},
			{name: 'name', type: 'string'},
			{name: 'visibility', type: 'bool'},
			{name: 'wkb_geom', type: 'string'},
			{name: 'description', type: 'string'},
			//{name: 'date_start', type: 'date', dateFormat: 'Y/m/d H:i:s'},
			//{name: 'date_start', type: 'date', dateFormat: 'Y/m/d'}, // Fehler: Datum wird nicht initialisiert
			//{name: 'date_end', type: 'date', dateFormat: 'Y/m/d'}, // s.o.
			{name: 'date_start', type: 'string'},
			{name: 'date_end', type: 'string'},
			{name: 'category', type: 'string'},
			{name: 'user_id', type: 'int'}
		]);
		
		jsonReaderMeasures = new Ext.data.JsonReader({
			totalProperty: "count",    // The property which contains the total dataset size (optional)
			root: "measures", //root: "rows",                // The property which contains an Array of row objects
			id: "id"                     // The property within each row object that provides an ID for the record (optional)
		}, geops.wika.measureRecord);
		
		measureProxy =  new Ext.data.HttpProxy({
			url: geops.wika.rootdir + '/measure/loadmeasures',
			method: 'POST'
			}),
			
		// Hier geojson abfangen, da im Record nicht mehr vorhanden!
		measureProxy.on('load', function(ths, o, arg)
			{
				//geops.wika.vectorLayer.destroyFeatures();
				geops.wika.vectorLayer.removeFeatures(geops.wika.vectorLayer.features);
				var measures = o.reader.jsonData.measures;
				var geojson = new OpenLayers.Format.GeoJSON();
				//alert(1);
				
				for(var i=0; i<measures.length; i++)
				{
					json = o.reader.jsonData.measures[i].geojson;
					feature_coll = geojson.read(json);
					geops.wika.vectorLayer.addFeatures(feature_coll);
				}
			});
		
		geops.wika.dsMeasures = new Ext.data.Store({
			proxy: measureProxy,
			reader: jsonReaderMeasures
		});
		
		geops.wika.dsMeasures.on('loadexception', function() {
			Ext.MessageBox.alert('Warning','DataStore Measures could not be loaded.');
		});
	
		geops.wika.dsMeasures.on('load', function(){
			//for(var i=0; i<geops.wika.dsMeasures.
			geops.wika.dsMeasuresLoaded = true;
		});

		categoryRecord = Ext.data.Record.create([
			{name: 'id', type: 'int'},
			{name: 'name', type: 'string'}
		]);
		
		jsonReaderCategories = new Ext.data.JsonReader({
			totalProperty: "count",
			root: "categories",
			id: "id"
		}, categoryRecord);

		geops.wika.dsCategories = new Ext.data.Store({
			proxy: new Ext.data.HttpProxy({
			url: geops.wika.rootdir + '/category/loadcategories',
			method: 'POST'
			}),
			reader: jsonReaderCategories
		});
		
		geops.wika.dsCategories.on('loadexception', function() {
		Ext.MessageBox.alert('Warning','DataStore Categories could not be loaded.');
		});
	
		geops.wika.dsCategories.on('load', function(){geops.wika.dsCategoriesLoaded = true;});

		geops.wika.dsCategories.load();
		
		userRecord = Ext.data.Record.create([
			{name: 'id', type: 'int'},
			{name: 'username', type: 'string'}
		]);
		
		jsonReaderUsers = new Ext.data.JsonReader({
			totalProperty: "count",
			root: "users",
			id: "id"
		}, userRecord);

		geops.wika.dsUsers = new Ext.data.Store({
			proxy: new Ext.data.HttpProxy({
			url: geops.wika.rootdir + '/user/loadusers',
			method: 'POST'
			}),
			reader: jsonReaderUsers
		});
		
		geops.wika.dsUsers.on('loadexception', function() {
		Ext.MessageBox.alert('Warning','DataStore Users could not be loaded.');
		});
	
		geops.wika.dsUsers.on('load', function(){geops.wika.dsUsersLoaded = true;});

		geops.wika.dsUsers.load();
		
		geops.wika.mainaxisRecord = Ext.data.Record.create([
			{name: 'gid', type: 'int'},
			{name: 'wkb_geom', type: 'string'}
		]);
		
		jsonReaderMainaxes = new Ext.data.JsonReader({
			totalProperty: "count",    // The property which contains the total dataset size (optional)
			root: "mainaxes", // The property which contains an Array of row objects
			id: "gid"                     // The property within each row object that provides an ID for the record (optional)
		}, geops.wika.mainaxisRecord);
		
		mainaxesProxy =  new Ext.data.HttpProxy({
			url: geops.wika.rootdir + '/mainaxes/loadmainaxes',
			method: 'POST'
			}),
			
		// Hier geojson abfangen, da im Record nicht mehr vorhanden!
		mainaxesProxy.on('load', function(ths, o, arg)
		{
			//geops.wika.vectorLayer.destroyFeatures();
			geops.wika.vectorLayer.removeFeatures(geops.wika.vectorLayer.features);
			var mainaxes = o.reader.jsonData.mainaxes;
			var geojson = new OpenLayers.Format.GeoJSON();
			
			for(var i=0; i<mainaxes.length; i++)
			{
				json = mainaxes[i].geojson;
				feature_coll = geojson.read(json);
				geops.wika.vectorLayer.addFeatures(feature_coll);
			}
		});
		
		geops.wika.dsMainaxes = new Ext.data.Store({
			proxy: mainaxesProxy,
			reader: jsonReaderMainaxes
		});
		
		geops.wika.dsMainaxes.on('loadexception', function() {
			Ext.MessageBox.alert('Warning','DataStore Mainaxes could not be loaded.');
		});
	
		geops.wika.dsMainaxes.on('load', function(){
			geops.wika.dsMainaxesLoaded = true;
		});
		
	}
	
	return {
		init: function(loggedIn, user, userId, rootdir) {
			geops.wika.loggedIn = loggedIn;
			geops.wika.rootdir = rootdir;
			geops.wika.user = user;
			geops.wika.userId = userId;
			geops.wika.pageLimitMeasures = 10;
			
			// Workaround fr ExtJS-Bug: Event 'check' fr Radiobuttons wird pro Button nur einmal ausgel�t
			Ext.override(Ext.form.Radio, {
			    onClick : function(){
			    	if(this.el.dom.checked != this.checked){
			    		var p = this.el.up('form') || Ext.getBody();
						var els = p.select('input[name='+this.el.dom.name+']');
						els.each(function(el){
							if(el.dom.id == this.id){
								this.setValue(true);
							}else{
								Ext.getCmp(el.dom.id).setValue(false);
							}
						}, this);
					}
			    }
			});

			initLocalizations();
			initData();
			initMap();
			initLayout();
			initToolbar();
			initFooter(user);
			
			if(geops.wika.loggedIn)
			{
				enableUserControls();
				
				// add mainaxesPanel if not already
				if(!geops.wika.mainaxesPanel)
				{
					geops.wika.mainaxesPanel = new Ext.Panel({
						baseCls: 'ext_panel_accordion',
						title: 'Hauptachsen',
						autoHeight: true
					});
					geops.wika.sideMenu.add(geops.wika.mainaxesPanel);
					resizeTrick();
					geops.wika.mainaxesPanel.on('expand', function(panel){resizeTrick(panel);initMainaxesPanelElements();switchPanel('mainaxes');});
				}
			}
			
			// Bei Anpassung Browserfenster Kartendimensionen anpassen um Layer-Verschiebung zu verhindern
			//document.body.writeAttribute("onresize", "geops.wika.map.updateSize();"); // funktioniert nicht im IE!
		} // end of init
	} // end of return
}();