[Mapbender-dev] tab_open undefined

Balázs Bámer bamerbalazs at gmail.com
Wed Mar 18 10:04:33 EDT 2009


Hi Developers,

I've downloaded 2.5.1 and ran in the same problems as in 2.5.
Problem: I use no tabs, and this causes blocking when calling
parent.tab_open for
http/javascripts/mod_digitize_tab.php
http/javascripts/mod_wfs_SpatialRequest.php

I suggest try{} block with empty catch {} as in attached files.

best regards: Balázs Bámer
-------------- next part --------------
<?php
# $Id: mod_digitize_tab.php 3513 2009-02-04 09:25:52Z verenadiewald $
# http://www.mapbender.org/index.php/mod_digitize_tab.php
# Copyright (C) 2002 CCGIS 
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

require_once(dirname(__FILE__) . "/../php/mb_validateSession.php");

$e_target = $_GET["e_target"];
?>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="expires" content="0">
<?php
echo '<meta http-equiv="Content-Type" content="text/html; charset='.CHARSET.'">';	
?>
<title>Digitize</title>
<?php
$digitize_conf_filename = "digitize_default.conf";
include '../include/dyn_css.php';
?>
<script language='JavaScript'>
//
// Buttons
//
function addButtonDig(id, isOn, src, titleOff, titleOn, x, y) {
	buttonDig_id.push(id);
	buttonDig_on.push(isOn);
	buttonDig_src.push(src);
	buttonDig_title_off.push(titleOff);
	buttonDig_title_on.push(titleOn);
	buttonDig_x.push(x);
	buttonDig_y.push(y);
}

function htmlspecialchars(p_string) {
	p_string = p_string.replace(/&/g, '&amp;');
	p_string = p_string.replace(/</g, '&lt;');
	p_string = p_string.replace(/>/g, '&gt;');
	p_string = p_string.replace(/"/g, '&quot;');
	//	p_string = p_string.replace(/'/g, '&#039;');
	return p_string;
};

var buttonDig_imgdir = "../img/button_digitize/";
var buttonDig_id = [];
var buttonDig_on = [];
var buttonDig_src = [];
var buttonDig_title_off = [];
var buttonDig_title_on = [];
var buttonDig_x = [];
var buttonDig_y = [];	

<?php
echo "var mod_digitize_target = '".$e_target."';";
$digitizeConfFilenameAndPath = dirname(__FILE__) . "/../../conf/" . $digitize_conf_filename;
if ($digitize_conf_filename && file_exists($digitizeConfFilenameAndPath)) {
	include($digitizeConfFilenameAndPath);
}
?>

var wfsWindow;	
var dwin = null;
var wfsConf = [];
var d;
var mod_digitize_width;
var mod_digitize_height;
var mod_digitizeEvent = false;
var nonTransactionalHighlight;

var button_point = "Point";
var button_line = "Line";
var button_polygon = "Polygon";
var button_move = "dragBasePoint";
var button_insert = "setBasePoint";
var button_delete = "delBasePoint";
var button_clear = "clear";
var button_combine = "combine";

var digitizeDivTag;

var GeometryArray;
var MultiGeometry = parent.MultiGeometry;
var Geometry;
var Point;
var geomType;

var msgObj;
var featureTypeElementFormId = "featureTypeElementForm";

try {if(mod_digitize_elName){}}catch(e) {mod_digitize_elName = "digitize";}
try {if(nonTransactionalEditable){}}catch(e) {nonTransactionalEditable = false;}

function initializeDigitize () {
	d = new parent.GeometryArray();
	GeometryArray = parent.GeometryArray;
	Geometry = parent.Geometry;
	Point = parent.Point;
	geomType = parent.geomType;
}

/**
 * Append geometries from KML when KML has been loaded
 */
function appendGeometryArrayFromKML () {
	try {
		parent.kmlHasLoaded.register(function(properties){
			d = new parent.GeometryArray();
			d.importGeoJSON(properties);		
//			d = parent.geoJsonToGeometryArray(properties);
			executeDigitizeSubFunctions();
		});
	}
	catch (e) {
		var exc = new parent.Mb_warning(e);
	}
}


// ------------------------------------------------------------------------------------------------------------------------
// --- polygon, line, point insertion (begin) ----------------------------------------------------------------------------------------------

function appendGeometryArray(obj) {
	executeDigitizePreFunctions();
	for (i=0; i<obj.count(); i++) {
		d.addCopy(obj.get(i));
	}
	executeDigitizeSubFunctions();
}

function mod_digitize_go(e){
	parent.mb_registerGML(mod_digitize_target,d);   

	// ie workaround
	if (e == undefined) {
		e = parent.frames[mod_digitize_target].event;
	}
	if (e) {
		// track mouse position
		parent.mb_getMousePos(e, mod_digitize_target);
		var currentPos = new parent.Point(parent.clickX, parent.clickY);
		s.check(currentPos);
	}
	else {
//		s.clean();
	}

	var el = parent.frames[mod_digitize_target].document;
	el.onmousedown = mod_digitize_start;
}

function mod_digitize_timeout(){
	var el = parent.frames[mod_digitize_target].document;
	el.onmousedown = null;
	el.onmouseup = null;
	el.onmousemove = null;
}

function mod_digitize_start(e){
	// check if a proper geometry is selected	
	if (d.getGeometry(-1,-1).isComplete() || d.count() == 0){
		
		if (mod_digitizeEvent != false) {
			alert(msgObj.errorMessageNoGeometrySelected);
		}
		return false;
	}
	
	var realWorldPos;
	if (s.isSnapped()) {
		realWorldPos = s.getSnappedPoint(); 
		s.clean();
	}
	else {
		parent.mb_getMousePos(e,mod_digitize_target);
		realWorldPos = parent.mapToReal(mod_digitize_target,new parent.Point(parent.clickX,parent.clickY));
	}
	
	if (d.get(-1).geomType == parent.geomType.polygon && d.getGeometry(-1,-1).count() > 1 && d.getGeometry(-1,-1).get(0).equals(realWorldPos)) {
				
		// close the polygon
		d.close();
		parent.mb_disableThisButton(button_polygon);
		return true;
	}
	else if (d.get(-1).geomType == parent.geomType.line && d.getGeometry(-1,-1).count() > 1 && d.getGeometry(-1,-1).get(-1).equals(realWorldPos)) {
		// close the line
		d.close();
		parent.mb_disableThisButton(button_line);
		return true;
	}
	else {
		// set the calculated real world position as point of the geometry
		d.getGeometry(-1,-1).addPoint(realWorldPos);
		
		if(d.get(-1).geomType == parent.geomType.point){
			d.close();
			parent.mb_disableThisButton(button_point);
			return true;
		}
		
		// add first point of polygon to snapping list (if three points have been inserted).
		else if (d.get(-1).geomType == parent.geomType.polygon && d.getGeometry(-1,-1).count() == 3) {
			s.add(d.getPoint(-1, -1, 0));
		}

		// add last point of line to snapping list (if at least two points have been inserted).
		else if (d.get(-1).geomType == parent.geomType.line && d.getGeometry(-1,-1).count() >= 2) {
			if (mod_digitizeEvent != button_move) {
				s.store(d);
			}
			s.add(d.getPoint(-1, -1, -1));
		}
	}
	executeDigitizeSubFunctions();
	return true;
}
// --- polygon, line, point insertion (begin) ----------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------------------------------
// --- basepoint handling (begin) -----------------------------------------------------------------------------------------

var basepointObject = false;
var basepointMemberIndex = null;
var basepointGeometryIndex = null;
var basepointPointIndex = null;
var basepointDragActive = false;

function handleBasepoint(obj,memberIndex,geometryIndex,pointIndex){
	if(!(mod_digitizeEvent == button_move || mod_digitizeEvent == button_insert || mod_digitizeEvent == button_delete)){ return false; }
	
	basepointObject = obj;
	basepointMemberIndex = memberIndex;
	basepointGeometryIndex = geometryIndex;
	basepointPointIndex = pointIndex;
	
	if(mod_digitizeEvent == button_move){
		mod_digitize_timeout();
		basepointObject.style.cursor = 'move';
		basepointObject.onmousedown = parent.window.frames[mod_digitize_elName].selectBasepoint;
	}

	if(mod_digitizeEvent == button_delete){
		mod_digitize_timeout();
		basepointObject.style.cursor = 'crosshair';
		basepointObject.onmousedown = parent.window.frames[mod_digitize_elName].deleteBasepoint;
	}
}

function convertLinepointToBasepoint(obj, memberIndex, geomIndex, pointIndex){
	if(!(mod_digitizeEvent == button_insert)){ return false; }
	
	if(mod_digitizeEvent == button_insert){
		mod_digitize_timeout();
		obj.style.cursor = 'crosshair';
		obj.onclick = insertBasepoint;

		basepointObject = obj;
		basepointMemberIndex = memberIndex;
		basepointGeometryIndex = geomIndex;
		basepointPointIndex = pointIndex;
	}
}

function insertBasepoint(e){
	var i = basepointMemberIndex;
	var j = basepointGeometryIndex;
	var k = basepointPointIndex;
	
	parent.mb_getMousePos(e, mod_digitize_target);
	var pos = parent.makeClickPos2RealWorldPos(mod_digitize_target,parent.clickX, parent.clickY);
	var p = new parent.Point(pos[0], pos[1]);
	d.getGeometry(i,j).addPointAtIndex(p, k);

	executeDigitizeSubFunctions();
}

function deleteBasepoint(){
	var i = basepointMemberIndex;
	var j = basepointGeometryIndex;
	var k = basepointPointIndex;
	d.delAllPointsLike(d.getPoint(i,j,k));

	executeDigitizeSubFunctions();
}

function selectBasepoint(e){
	if(!basepointDragActive && mod_digitizeEvent == button_move){
		basepointDragActive = true;
		s.store(d, d.getPoint(basepointMemberIndex, basepointGeometryIndex, basepointPointIndex));
		// replace basepoint by transparent blob
		basepointObject.style.width = mod_digitize_width;
		basepointObject.style.height = mod_digitize_height;
		basepointObject.style.left = 0;
		basepointObject.style.top = 0;
			
		if (parent.ie) {
			// ie cannot handle backgroundColor = 'transparent'
			basepointObject.style.background = "url(../img/transparent.gif)";
		}
		else{
			basepointObject.style.backgroundColor = 'transparent';
		}

		basepointObject.onmouseup = releaseBasepoint;
		basepointObject.onmousemove = dragBasepoint;
	}
}

function dragBasepoint(e){
	if(basepointDragActive){
		parent.mb_getMousePos(e, mod_digitize_target);
		var currentPos = new parent.Point(parent.clickX, parent.clickY);
		var res = s.check(currentPos);

	}
}
	
function updateAllPointsOfNonTransactionalLike(oldP, newP){ 
	for (var i = 0; i < d.count(); i++) {
		if (isTransactional(d.get(i))) {
			d.get(i).updateAllPointsLike(oldP, newP);
		}
	}
}

	
function releaseBasepoint(e){
	
	var i = basepointMemberIndex;
	var j = basepointGeometryIndex;
	var k = basepointPointIndex;
	basepointDragActive = false;
	
	parent.mb_getMousePos(e, mod_digitize_target);
	var basepointDragEnd = new parent.Point(parent.clickX, parent.clickY);
	basepointObject.onmousedown = null;
	var p = parent.makeClickPos2RealWorldPos(mod_digitize_target, basepointDragEnd.x, basepointDragEnd.y);

	var oldPoint = parent.cloneObject(d.getPoint(i,j,k));
	if (s.isSnapped()) {
		var snappedPoint = parent.cloneObject(s.getSnappedPoint());
		if (!nonTransactionalEditable) {
			updateAllPointsOfNonTransactionalLike(oldPoint, snappedPoint);
		}
		else {
			d.updateAllPointsLike(oldPoint, snappedPoint);
		}
		s.clean();
	}
	else {
		var newPoint = new parent.Point(p[0],p[1]);
		if (!nonTransactionalEditable) {
			updateAllPointsOfNonTransactionalLike(oldPoint, newPoint);
		}
		else {
			d.updateAllPointsLike(oldPoint, newPoint);
		}
	}
	basepointMemberIndex = null;
	basepointGeometryIndex = null;
	basepointPointIndex = null;	
		
	executeDigitizeSubFunctions();
}
// --- basepoint handling (end) -----------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------
	
// ------------------------------------------------------------------------------------------------------------------------
// --- registered functions (begin) ---------------------------------------------------------------------------------------

function registerDigitizePreFunctions(stringFunction){
	mod_digitizePreFunctions[mod_digitizePreFunctions.length] = stringFunction;
}

function registerDigitizeSubFunctions(stringFunction){
	mod_digitizeSubFunctions[mod_digitizeSubFunctions.length] = stringFunction;
}

function executeDigitizeSubFunctions(){
//	console.profile();
	for(var i=0; i<mod_digitizeSubFunctions.length; i++){
		eval(mod_digitizeSubFunctions[i]);
	}
//	console.profileEnd();
}

function executeDigitizePreFunctions(){
	for(var i=0; i<mod_digitizePreFunctions.length; i++){
		eval(mod_digitizePreFunctions[i]);
	}
}

function registerFunctions(){
	mod_digitizePreFunctions = [];
	mod_digitizeSubFunctions = [];
	registerDigitizePreFunctions("updateExtent()");
	registerDigitizePreFunctions("drawDashedLine()");
	registerDigitizeSubFunctions("updateListOfGeometries()");
	registerDigitizeSubFunctions("drawDashedLine()");
	parent.mb_registerInitFunctions("window.frames['"+ mod_digitize_elName + "'].initializeDigitize()");
	parent.mb_registerInitFunctions("window.frames['"+ mod_digitize_elName + "'].setStyleForTargetFrame()");
	parent.mb_registerInitFunctions("window.frames['"+ mod_digitize_elName + "'].checkDigitizeTag()");
	parent.mb_registerInitFunctions("window.frames['"+ mod_digitize_elName + "'].initialiseSnapping()");
	parent.mb_registerL10nFunctions("window.frames['"+ mod_digitize_elName + "'].getMessages()");
//	parent.mb_registerInitFunctions("window.frames['"+ mod_digitize_elName + "'].appendGeometryArrayFromKML()");
	if (!nonTransactionalEditable) {
		parent.mb_registerInitFunctions("window.frames['"+ mod_digitize_elName + "'].initialiseHighlight()");
	}
	parent.mb_registerInitFunctions("window.frames['"+ mod_digitize_elName + "'].initialiseMeasure()");
	parent.mb_registerInitFunctions("window.frames['"+ mod_digitize_elName + "'].getMessages()");
	parent.mb_registerSubFunctions("window.frames['" + mod_digitize_elName + "'].updateExtent()");
	try {if(spatialRequestResultToDigitize){}}catch(e) {spatialRequestResultToDigitize = 1;}
	if(spatialRequestResultToDigitize==1){
		parent.mb_registerWfsReadSubFunctions(function(geom){
		try {
			parent.tab_open(mod_digitize_elName);
		}
		catch(err) {}
		parent.window.frames[mod_digitize_elName].appendGeometryArray(geom);});
	}
	parent.mb_registerWfsWriteSubFunctions(function(){parent.zoom(mod_digitize_target, true, 0.999);});
}

function checkDigitizeTag(){
	var digitizeTagName = "digitize";
	var digitizeTagStyle = {"position":"absolute", "top":"0px", "left":"0px", "z-index":digitizeTransactionalZIndex, "font-size":"10px"};
	 
	digitizeDivTag = new parent.DivTag(digitizeTagName, mod_digitize_target, digitizeTagStyle);
	parent.mb_registerPanSubElement(digitizeTagName);
	parent.mb_registerSubFunctions("window.frames['"+ mod_digitize_elName + "'].drawDashedLine()");
}


function setStyleForTargetFrame(){
	var cssLink = parent.window.frames[mod_digitize_target].document.createElement("link");
	cssLink.setAttribute("href", cssUrl); 
	cssLink.setAttribute("type", "text/css"); 
	cssLink.setAttribute("rel", "stylesheet"); 
	var cssTmp = parent.window.frames[mod_digitize_target].document.getElementsByTagName("head")[0];
	cssTmp.appendChild(cssLink);
}

function initialiseSnapping(){
	s = new parent.Snapping(mod_digitize_target, snappingTolerance, snappingColor, snappingHighlightZIndex);
}
function initialiseHighlight(){
	nonTransactionalHighlight = new parent.Highlight(new Array(mod_digitize_target), "nonTransactional", {"position":"absolute", "top":"0px", "left":"0px", "z-index":digitizeNonTransactionalZIndex}, nonTransactionalLineWidth);
}
function initialiseMeasure(){
	measureDivTag = new parent.DivTag(measureTagName, measureTagTarget, measureTagStyle);
	parent.mb_registerSubFunctions("window.frames['"+ mod_digitize_elName + "'].updateMeasureTag()");
}
// --- registered functions (end) -----------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------


function updateMeasureTag () {
	if (d.count() > 0 ) {
		if (d.get(-1).count() > 0) {
			if (d.getGeometry(-1, -1).count() > 0) {
				if (mod_digitizeEvent == button_line || mod_digitizeEvent == button_polygon) {
					var measureString = "";
					measureString += msgObj.measureTagLabelCurrent + d.getGeometry(-1, -1).getCurrentDist(measureNumberOfDigits) + "<br>";
					measureString += msgObj.measureTagLabelTotal + d.getGeometry(-1, -1).getTotalDist(measureNumberOfDigits);
					measureDivTag.write(measureString);
					return true;
				}
			}
		}
	}
	measureDivTag.clean();
}



// ------------------------------------------------------------------------------------------------------------------------
// --- button handling (begin) --------------------------------------------------------------------------------------------

function displayButtons(){
	for (var i = 0 ; i < buttonDig_id.length ; i ++) {
		if (parseInt(buttonDig_on[i])==1) {
			var divTag = document.createElement("div");
			divTag.setAttribute("id", "div_" + buttonDig_id[i]);
// FIREFOX 
			document.getElementById("digButtons").appendChild(divTag);

//IE WORKAROUND, WORKS ALSO FOR FIREFOX
			var tagContent = "<div style='position:absolute; top:"+buttonDig_y[i]+"px; left:"+buttonDig_x[i]+"px;'><img name=\""+buttonDig_id[i]+"\" onmouseover=\"parent.mb_regButton_frame('initDigButton', mod_digitize_elName, "+i+");\" id=\""+buttonDig_id[i]+"\" title=\""+buttonDig_title_off[i]+"\" src=\""+buttonDig_imgdir+buttonDig_src[i]+"\"></div>";
			parent.writeTag(mod_digitize_elName,"div_" + buttonDig_id[i],tagContent);
		}
	}
}

function updateButtons() {
	for (var i = 0 ; i < buttonDig_id.length ; i ++) {
		if (parseInt(buttonDig_on[i])==1) {
			var currentButton = document.getElementById(buttonDig_id[i]);
			var currentStatus = buttonDig_id[i].status;
			var currentTitle = "";
			switch (buttonDig_id[i]) {
				case "Point":
					if (currentStatus == 1) {
						currentTitle = msgObj.buttonLabelPointOn;
					}
					else {
						currentTitle = msgObj.buttonLabelPointOff;
					}
					break;
				case "Line":
					if (currentStatus == 1) {
						currentTitle = msgObj.buttonLabelLineOn;
					}
					else {
						currentTitle = msgObj.buttonLabelLineOff;
					}
					break;
				case "Polygon":
					if (currentStatus == 1) {
						currentTitle = msgObj.buttonLabelPolygonOn;
					}
					else {
						currentTitle = msgObj.buttonLabelPolygonOff;
					}
					break;
				case "dragBasePoint":
					if (currentStatus == 1) {
						currentTitle = msgObj.buttonLabelMoveBasepointOn;
					}
					else {
						currentTitle = msgObj.buttonLabelMoveBasepointOff;
					}
					break;
				case "setBasePoint":
					if (currentStatus == 1) {
						currentTitle = msgObj.buttonLabelInsertBasepointOn;
					}
					else {
						currentTitle = msgObj.buttonLabelInsertBasepointOff;
					}
					break;
				case "delBasePoint":
					if (currentStatus == 1) {
						currentTitle = msgObj.buttonLabelDeleteBasepointOn;
					}
					else {
						currentTitle = msgObj.buttonLabelDeleteBasepointOff;
					}
					break;
				case "clear":
					if (currentStatus == 1) {
						currentTitle = msgObj.buttonLabelClearListOn;
					}
					else {
						currentTitle = msgObj.buttonLabelClearListOff;
					}
					break;
			}
			currentButton.title = currentTitle;
		}
	}
}

function initDigButton(ind, pos){
	parent.mb_button[ind] = document.getElementById(buttonDig_id[pos]);
	parent.mb_button[ind].img_over = buttonDig_imgdir + buttonDig_src[pos].replace(/_off/,"_over");
	parent.mb_button[ind].img_on = buttonDig_imgdir + buttonDig_src[pos].replace(/_off/,"_on");
	parent.mb_button[ind].img_off = buttonDig_imgdir + buttonDig_src[pos];
	parent.mb_button[ind].title_on = buttonDig_title_on[pos];
	parent.mb_button[ind].title_off = buttonDig_title_off[pos];
	parent.mb_button[ind].status = 0;
	parent.mb_button[ind].elName = buttonDig_id[pos];
	parent.mb_button[ind].fName = "";
	parent.mb_button[ind].go = new Function ("digitizeEnable(parent.mb_button["+ind+"])");
	parent.mb_button[ind].stop = new Function ("digitizeDisable(parent.mb_button["+ind+"])");
}	

function digitizeEnable(obj) {
	if (obj.id == button_move || obj.id == button_insert || obj.id == button_delete) {
		mod_digitizeEvent = obj.id;
		executeDigitizePreFunctions();
	}
	else if (obj.id == button_point || obj.id == button_line || obj.id == button_polygon || obj.id == button_clear || obj.id == button_combine){
		var el = parent.frames[mod_digitize_target].document;
		el.onmousemove = mod_digitize_go;

		mod_digitizeEvent = obj.id;

		if (mod_digitizeEvent == button_point || mod_digitizeEvent == button_line || mod_digitizeEvent == button_polygon || mod_digitizeEvent == button_insert ) {
			s.store(d);
		}

		executeDigitizePreFunctions();
		obj.title = obj.title_on;
		if (obj.id == button_point) {
			if (d.count() > 0 && d.get(-1).count() > 0 && !d.get(-1).get(-1).isComplete()) {
				if (d.get(-1).geomType != parent.geomType.point) {
					d.close();
					executeDigitizeSubFunctions();
				}
				else {
					s.add(d.getPoint(-1, -1, 0));
				}
			}
			if (d.count() == 0 || (d.count() > 0 && d.get(-1).count() > 0 && d.get(-1).get(-1).isComplete())) {
				d.addMember(parent.geomType.point);
				d.get(-1).addGeometry();
			}
			else {
/*
//
// delete existing line or polygon
//	
				d.del(-1);
				d.addMember(parent.geomType.point);
				d.get(-1).addGeometry();
*/
			}
		}
		else if (obj.id == button_polygon) {
			if (d.count() > 0 && d.get(-1).count() > 0 && !d.get(-1).get(-1).isComplete()) {
				if (d.get(-1).geomType != parent.geomType.polygon) {
					d.close();
					executeDigitizeSubFunctions();
				}
				else {
					s.add(d.getPoint(-1, -1, 0));
				}
			}
			if (d.count() == 0 || (d.count() > 0 && d.get(-1).count() > 0 && d.get(-1).get(-1).isComplete())) {
				// new geometry
				d.addMember(parent.geomType.polygon);
				d.get(-1).addGeometry();
			}
			else {
/*
//
// continue a line as a polygon
//	
				if (d.get(-1).geomType != parent.geomType.polygon) {
					var geometryTemplate = parent.cloneObject(d.get(-1));
					d.del(-1);
					d.addMember(parent.geomType.polygon);
					for (var i = 0; i < geometryTemplate.count(); i++) {
						d.get(-1).addGeometry();
						for (var j = 0; j < geometryTemplate.get(i).count(); j++) {
							d.get(-1).get(-1).addPoint(geometryTemplate.get(i).get(j));
						}
					}
				}
				s.add(d.getPoint(-1, -1, 0));
*/
			}
		}
		else if (obj.id == button_line) {
			if (d.count() > 0 && d.get(-1).count() > 0 && !d.get(-1).get(-1).isComplete()) {
				if (d.get(-1).geomType != parent.geomType.line) {
					d.close();
					executeDigitizeSubFunctions();
				}
				else {
					s.add(d.getPoint(-1, -1, 0));
				}
			}
			if (d.count() == 0 || (d.count() > 0 && d.get(-1).count() > 0 && d.get(-1).get(-1).isComplete())) {
				d.addMember(parent.geomType.line);
				d.get(-1).addGeometry();
			}
			else {
/*
//
// continue a polygon as a line
//	
				if (d.get(-1).geomType != parent.geomType.line) {
					var geometryTemplate = parent.cloneObject(d.get(-1));
					d.del(-1);
					d.addMember(parent.geomType.line);
					for (var i = 0; i < geometryTemplate.count(); i++) {
						d.get(-1).addGeometry();
						for (var j = 0; j < geometryTemplate.get(i).count(); j++) {
							d.get(-1).get(-1).addPoint(geometryTemplate.get(i).get(j));
						}
					}
				}
*/
			}
		}
		else if (obj.id == button_clear) {
			var clear = confirm(msgObj.messageConfirmDeleteAllGeomFromList);
			if (clear) {
				d = new parent.GeometryArray();
				parent.mb_disableThisButton(button_clear);
			}
		}
		else if (obj.id == button_combine) {
//			d.combineToMultiGeometry();
//			prompt('', d.toJSONString());
//			parent.mb_ajax_post("../php/jsonTest.php", {json:d.toJSONString()}, function(test, status) {
//				alert(test);
//			});
			parent.mb_disableThisButton(button_combine);
		}
	}
}

function digitizeDisable(obj) {
	if (obj.id == button_point || obj.id == button_line || obj.id == button_polygon){
		obj.title = obj.title_off;
		if (d.get(-1).get(-1).count() == 0) {
			d.delGeometry(-1,-1);
		}
		mod_digitize_timeout();
		executeDigitizeSubFunctions();
	}
	else if (obj.id == button_clear) {
		mod_digitize_timeout();
		executeDigitizeSubFunctions();
	}
	mod_digitizeEvent = false;
}
// --- button handling (end) ----------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------------------

// -----------------------------------------------------------------------------------------------------------
// --- display (begin) -----------------------------------------------------------------------------------------

function updateExtent() {
	var anInd = parent.getMapObjIndexByName(mod_digitize_target);
	var change = false;
	if (typeof(mod_digitize_width) == 'undefined' || mod_digitize_width != parent.mb_mapObj[anInd].width) {
		mod_digitize_width = parent.mb_mapObj[anInd].width;
		change = true;
	}
	if (typeof(mod_digitize_height) == 'undefined' || mod_digitize_height != parent.mb_mapObj[anInd].height) {
		mod_digitize_height = parent.mb_mapObj[anInd].height;
		change = true;
	}
	if (typeof(mod_digitize_epsg) == 'undefined' || mod_digitize_epsg != parent.mb_mapObj[anInd].epsg) {
		mod_digitize_epsg = parent.mb_mapObj[anInd].epsg;
		change = true;
	}
//	if (change) {
//		drawDashedLine();
//	}
}

function drawDashedLine(){
	if (!nonTransactionalEditable) {
		nonTransactionalHighlight.clean();
	}
	var smP = "";
	smP += "<div class='t_img'>";
	smP += "<img src='"+parent.mb_trans.src+"' width='"+mod_digitize_width+"' height='0'></div>";
	smP += "<div class='t_img'>";
	smP += "<img src='"+parent.mb_trans.src+"' width='0' height='"+mod_digitize_height+"'></div>";

	if (!nonTransactionalEditable) {
		nonTransactionalHighlight.clean();
	}
	var smPArray = [];
	smPArray[smPArray.length] = "<div class='t_img'>"
			+ "<img src='"+parent.mb_trans.src+"' width='"+mod_digitize_width+"' height='0'></div>"
			+ "<div class='t_img'>"
			+ "<img src='"+parent.mb_trans.src+"' width='0' height='"+mod_digitize_height+"'></div>";
	
	var mapObj = parent.mb_mapObj[parent.getMapObjIndexByName(mod_digitize_target)];
	var width = mapObj.width;
	var height = mapObj.height;
	var arrayBBox = mapObj.extent.split(",")
	var minX = parseFloat(arrayBBox[0]);
	var minY = parseFloat(arrayBBox[1]);
	var maxX = parseFloat(arrayBBox[2]);
	var maxY = parseFloat(arrayBBox[3]);
	var cx = width/(maxX - minX);
	var cy = height/(maxY - minY);
	var isMoveOrInsertOrDelete = mod_digitizeEvent == button_move || mod_digitizeEvent == button_insert || mod_digitizeEvent == button_delete;
	var minDist = 6;

	for(var i=0, lenGeomArray = d.count(); i < lenGeomArray; i++){
		var currentGeomArray = d.get(i);

		if (!nonTransactionalEditable && !isTransactional(currentGeomArray)) {
			nonTransactionalHighlight.add(currentGeomArray, nonTransactionalColor);
		}
		else {
			for(var j=0, lenGeom = currentGeomArray.count(); j < lenGeom ; j++){
				var currentGeometry = d.getGeometry(i,j);
				var isPolygon = currentGeomArray.geomType == parent.geomType.polygon;
				var isLine = currentGeomArray.geomType == parent.geomType.line;
				var isComplete = currentGeometry.isComplete();
				var lastPaintedPoint = false;

				for(var k = 0, lenPoint = currentGeometry.count(); k < lenPoint; k++){
					var currentPoint = currentGeometry.get(k);
					var currentPointMap = new Point(Math.round((currentPoint.x - minX)*cx), Math.round((maxY - currentPoint.y)*cy));
					
//					var isTooCloseToPrevious = lastPaintedPoint && (k > 0) && Math.abs(currentPointMap.x-lastPaintedPoint.x) <= minDist && Math.abs(currentPointMap.y-lastPaintedPoint.y) <= minDist;
//					if (!isTooCloseToPrevious) {
						var currentPointIsVisible = currentPointMap.x > 0 && currentPointMap.x < width && currentPointMap.y > 0 && currentPointMap.y < height;
						if (currentPointIsVisible) {
							if (!isComplete && ((k == 0 && isPolygon) || (k == lenPoint-1 && isLine))) {
								smPArray[smPArray.length] = "<div class='bp' style='top:"+
									(currentPointMap.y-2)+"px;left:"+(currentPointMap.x-2)+"px;z-index:"+
									digitizeTransactionalZIndex+";background-color:"+linepointColor+"'";
							}
							else {
								smPArray[smPArray.length] = "<div class='bp' style='top:"+(currentPointMap.y-2)+"px;left:"+(currentPointMap.x-2)+"px;z-index:"+digitizeTransactionalZIndex+";'";
							}
							if(k==0 && isPolygon && !isComplete){
								smPArray[smPArray.length] = " title='"+msgObj.closePolygon_title+"' ";
							}
							if(isMoveOrInsertOrDelete) {
								smPArray[smPArray.length] = " onmouseover='parent.window.frames[\""+mod_digitize_elName+"\"].handleBasepoint(this,"+i+","+j+","+k+")' ;";
							}
							smPArray[smPArray.length] = "></div>";
							lastPaintedPoint = currentPointMap;
						}
						if (k > 0) {
							points = parent.calculateVisibleDash(currentPointMap, previousPointMap, width, height);
							if (points != false) {
								smPArray[smPArray.length] = evaluateDashes(points[0], points[1], i, j, k);
							}
						}
//					}
					var previousPointMap = currentPointMap;
				}
			}
		}
	}
	digitizeDivTag.write(smPArray.join(""));
}


function evaluateDashes(start, end, memberIndex, geomIndex, pointIndex){
	var strArray = [];
	var delta = new parent.Point(end.x - start.x, end.y - start.y);
	var lastGeomIsComplete = d.getGeometry(-1,-1).isComplete(); 
	 
	var vecLength = start.dist(end);
	var n = Math.round(vecLength/dotDistance);
	if (n > 0) {
		var step = delta.dividedBy(n);
	}
	for(var i=1; i < n; i++){
		var x = Math.round(start.x + i * step.x) - 2;
		var y = Math.round(start.y + i * step.y) - 2;
		if(x >= 0 && x <= mod_digitize_width && y >= 0 && y <= mod_digitize_height){
			if (memberIndex == d.count()-1 && !lastGeomIsComplete) {
				strArray[strArray.length] = "<div class='lp' style='top:"+y+"px;left:"+x+"px;z-index:"+digitizeTransactionalZIndex+";background-color:"+linepointColor+"' ";
			}
			else {
				strArray[strArray.length] = "<div class='lp' style='top:"+y+"px;left:"+x+"px;z-index:"+digitizeTransactionalZIndex+";' ";
			}
			if(mod_digitizeEvent == button_insert) {
				strArray[strArray.length] = "onmouseover='parent.window.frames[\""+mod_digitize_elName+"\"].convertLinepointToBasepoint(this,"+memberIndex+","+geomIndex+","+pointIndex+")'";
			}
			strArray[strArray.length] = "></div>";
		}
	}
	return strArray.join("");
}

function isTransactional(geom) {
//	alert(typeof(geom.wfs_conf) + " " + geom.wfs_conf + " " + wfsConf.length);
	if (typeof(geom.wfs_conf) == 'number') {
		if (geom.wfs_conf >= 0 && geom.wfs_conf < wfsConf.length) {			
			var isTransactionalGeom = (wfsConf[geom.wfs_conf]['wfs_transaction'] != "" && wfsConf[geom.wfs_conf]['fkey_featuretype_id'] != "");
			if (isTransactionalGeom) {
				return true;
			}
			else{
				return false;
			}
		}
	}
	else if (typeof(geom.wfs_conf) == 'undefined') {
		return true;
	}
}

function isValidWfsConfIndex (wfsConf, wfsConfIndex) {
	return (typeof(wfsConfIndex) == "number" && wfsConfIndex >=0 && wfsConfIndex < wfsConf.length);
}

function getName (geom) {
	wfsConfId = geom.wfs_conf;
	wfsConf = parent.get_complete_wfs_conf();
	if (isValidWfsConfIndex(wfsConf, wfsConfId)) {
		var resultName = "";
		for (var i = 0 ; i < wfsConf[wfsConfId]['element'].length ; i++) {
			if (wfsConf[wfsConfId]['element'][i]['f_show'] == 1) {
				resultName += geom.e.getElementValueByName(wfsConf[wfsConfId]['element'][i]['element_name']) + " ";
			}
		}
		if (resultName == "") {
			resultName = wfsConf[wfsConfId]['g_label'];
		}
		return resultName;
	}
	else if (geom.e.getElementValueByName("name")) {
		return geom.e.getElementValueByName("name");
	}
	else {
		return msgObj.digitizeDefaultGeometryName;
	}
}

function updateListOfGeometries(){
	var listOfGeom = "<table id='geometryTable' style='position:absolute; top:"+geomList_y+"px; left:"+geomList_x+"px;'>\n";
	if (d.count() > 0) {
		wfsConf = parent.get_complete_wfs_conf();
		for (var i = 0 ; i < d.count(); i ++) {

			if (d.get(i).get(-1).isComplete() && (nonTransactionalEditable || isTransactional(d.get(i)))) {
	
				// for the geometries from a kml, there is another save dialogue
				if (d.get(i).isFromKml()) {
					// if the kml is in the db (id = id in database)
					if (d.get(i).e.getElementValueByName("Mapbender:id")) {
						// button: geometry information, update kml
						listOfGeom += "\t<tr>\n\t\t<td>\n";
						listOfGeom += "\t\t\t<img src = '"+buttonDig_imgdir+buttonDig_wfs_src+"' title='"+msgObj.buttonDig_wfs_title+"' onclick='showWfsKml("+i+")'>\n";
					}
				}
				else {
					// button: geometry information, save, update, delete
					listOfGeom += "\t<tr>\n\t\t<td>\n";
					if (wfsExistsForGeom(d.get(i), wfsConf)) {
						listOfGeom += "\t\t\t<img src = '"+buttonDig_imgdir+buttonDig_wfs_src+"' title='"+msgObj.buttonDig_wfs_title+"' onclick='showWfs("+i+")'>\n";
					}
					listOfGeom += "\t\t</td>\n\t\t<td>\n";

					// button: remove this geometry
					listOfGeom += "\t\t\t<img src = '"+buttonDig_imgdir+buttonDig_remove_src+"' title='"+msgObj.buttonDig_remove_title+"' onclick='parent.mb_disableThisButton(mod_digitizeEvent);d.del("+i+");executeDigitizeSubFunctions();'>\n";
				}
				listOfGeom += "\t\t</td>\n\t\t<td>\n";
					
				// button: remove geometry from database
				if (d.get(i).e.getElementValueByName('fid')) { 
					listOfGeom += "\t\t\t<img src = '"+buttonDig_imgdir+buttonDig_removeDb_src+"' title='"+msgObj.buttonDig_removeDb_title+"' onclick=\"var deltrans = confirm('"+msgObj.messageConfirmDeleteGeomFromDb+"');if (deltrans) dbGeom('delete', "+i+")\">\n";
				}
				listOfGeom += "\t\t</td>\n\t\t<td style = 'color:blue;font-size:12px'>\n";
				listOfGeom += "\t\t\t<div onmouseover='parent.mb_wfs_perform(\"over\",d.get("+i+"));' ";
				listOfGeom += " onmouseout='parent.mb_wfs_perform(\"out\",d.get("+i+"))' ";
				listOfGeom += " onclick='parent.mb_wfs_perform(\"click\",d.get("+i+"));' ";
				var geomName = getName(d.get(i)); 
				if (d.get(i).geomType == parent.geomType.polygon) {geomName += " ("+msgObj.messageDescriptionPolygon+")";}
				else if (d.get(i).geomType == parent.geomType.line) {geomName += " ("+msgObj.messageDescriptionLine+")";}
				else if (d.get(i).geomType == parent.geomType.point) {geomName += " ("+msgObj.messageDescriptionPoint+")";}
				
				listOfGeom += ">" + htmlspecialchars(geomName) +"</div>\t\t</td>\n\t</tr>\n";
			}
		}
	}
	listOfGeom += "</table>\n";
	parent.writeTag(mod_digitize_elName,"listOfGeometries",listOfGeom);
}
// --- display (end) -----------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------------


// -----------------------------------------------------------------------------------------------------------
// --- wfs window (begin) -----------------------------------------------------------------------------------------

// -----------------------------------------------------------------------------------------------------------
// --- wfs window form check (begin) -----------------------------------------------------------------------------------------

function formCorrect(doc, formId) {
	var isCorrect = true;
	var errorMessage = "";
	var result;
	var form = doc.getElementById(formId);
	
	result = mandatoryFieldsNotEmpty(doc, form);
	isCorrect = isCorrect && result.isCorrect;
	errorMessage += result.errorMessage;

	result = validBoxEntrySelected(form);
	isCorrect = isCorrect && result.isCorrect;
	errorMessage += result.errorMessage;

	result = dataTypeIsCorrect(doc, form);
	isCorrect = isCorrect && result.isCorrect;
	errorMessage += result.errorMessage;

	return {"isCorrect":isCorrect, "errorMessage":errorMessage};
}

function validBoxEntrySelected(form){
	var isCorrect = true;
	var errorMessage = "";
	for (var i = 0; i < form.childNodes.length && isCorrect; i++) {
		if (form.childNodes[i].nodeName.toUpperCase() == "SELECT") {
			if (parseInt(form.childNodes[i].selectedIndex) == 0) {
				return {"isCorrect":false, "errorMessage":errorMessage};
			}
		}
		else if (form.childNodes[i].hasChildNodes()) {
			isCorrect = validBoxEntrySelected(form.childNodes[i]).isCorrect;
		}
	}
	if (!isCorrect) {
		errorMessage = msgObj.messageSelectAnOption + "\n";
	}
	return {"isCorrect":isCorrect, "errorMessage":errorMessage};
}

function mandatoryFieldsNotEmpty(doc, node){
	var isCorrect = true;
	var errorMessage = "";
	
	nodeArray = doc.getElementsByName("mandatory");
	for (var i = 0; i < nodeArray.length && isCorrect; i++) {
		if (nodeArray[i].nodeName.toUpperCase() == "INPUT" && nodeArray[i].type == "hidden" && nodeArray[i].id.substr(0,10) == "mandatory_") {
			var nodeId = nodeArray[i].id.substr(10);
			if (nodeArray[i].value == "true") {
				if (doc.getElementById(nodeId).value == "") {
					isCorrect = false;
					errorMessage += "'"+ doc.getElementById(nodeId).name +"': "+ msgObj.messageErrorFieldIsEmpty +"\n";
				}
			}
		}
	}
	return {"isCorrect":isCorrect, "errorMessage":errorMessage};
}

function isInteger(str) {
	if (str.match(/^\d*$/)) {
		return true;
	}
	return false;
}

function isFloat(str) {
	if (isInteger(str)) {
		return true;
	}
	if (str.match(/^\d+\.\d+$/)) {
		return true;
	}
	return false;
}

function replaceCommaByDecimalPoint(str) {
	var patternString = ",";
	var pattern = new RegExp(patternString);
	while (str.match(pattern)) {
		str = str.replace(pattern, ".");
	}
	return str;
}

function dataTypeIsCorrect(doc, node){
	var isCorrect = true;
	var errorMessage = "";
	
	nodeArray = doc.getElementsByName("datatype");
	for (var i = 0; i < nodeArray.length ; i++) {
		if (nodeArray[i].nodeName.toUpperCase() == "INPUT" && nodeArray[i].type == "hidden" && nodeArray[i].id.substr(0,9) == "datatype_") {
			var nodeId = nodeArray[i].id.substr(9);
			var nodeValue = doc.getElementById(nodeId).value;
			
			if (nodeArray[i].value == "int") {
				if (!isInteger(nodeValue)) {
					isCorrect = false;
					errorMessage += "'"+doc.getElementById(nodeId).name+"': "+ msgObj.messageErrorNotAnInteger + "\n";
				}
			}
			else if (nodeArray[i].value == "double") {
				nodeValue = replaceCommaByDecimalPoint(nodeValue);
				if (!isFloat(nodeValue)) {
					isCorrect = false;
					errorMessage += "'"+doc.getElementById(nodeId).name+"': "+ msgObj.messageErrorNotAFloat + "\n";
				}
				else {
					doc.getElementById(nodeId).value = nodeValue;
				}
			}
		}
	}
	return {"isCorrect":isCorrect, "errorMessage":errorMessage};
}
// --- wfs window form check (end) -----------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------------

function getAvailableWfsForGeom(geom, wfsConf) {
	var wfsConfIndices = [];
	
	for (var attr in wfsConf) {
		var isTrans = (wfsConf[attr]['wfs_transaction'] != "");
		if (!isTrans) {
			continue;
		}
		if (isValidWfsConfIndex(wfsConf, parseInt(geom.wfs_conf))) {
			
			if (parseInt(geom.wfs_conf) == parseInt(attr)) {
				wfsConfIndices.push(attr);
			}
		}
		else {
			for (var elementIndex = 0; elementIndex < wfsConf[attr]['element'].length ; elementIndex++) {
				var isGeomColumn = (parseInt(wfsConf[attr]['element'][elementIndex]['f_geom']) == 1); 
				if (isGeomColumn) {
					var isMultiPolygon = (geom.geomType == parent.geomType.polygon && wfsConf[attr]['element'][elementIndex]['element_type'] == 'MultiPolygonPropertyType');
					var isPolygon = (geom.geomType == parent.geomType.polygon && geom.count() == 1 && wfsConf[attr]['element'][elementIndex]['element_type'] == 'PolygonPropertyType');
					var isMultiLine = (geom.geomType == parent.geomType.line && wfsConf[attr]['element'][elementIndex]['element_type'] == 'MultiLineStringPropertyType');
					var isLine = (geom.geomType == parent.geomType.line && geom.count() == 1 && wfsConf[attr]['element'][elementIndex]['element_type'] == 'LineStringPropertyType');
					var isPoint = (geom.geomType == parent.geomType.point && wfsConf[attr]['element'][elementIndex]['element_type'] == 'PointPropertyType');
//					alert(isMultiPolygon + " " + isPolygon + " " + isMultiLine + " " + isLine + " " + isPoint);
					if (isMultiPolygon || isPolygon || isMultiLine || isLine || isPoint || wfsConf[attr]['element'][elementIndex]['element_type'] == 'GeometryAssociationType') {
						
						wfsConfIndices.push(attr);
					}
				}
			}
		}	
	}
	return wfsConfIndices;
}
function wfsExistsForGeom(geom, wfsConf) {
	wfsConfIndices = getAvailableWfsForGeom(geom, wfsConf);
//	alert(wfsConfIndices.join(","));
	if (wfsConfIndices.length > 0) {
		return true;
	}
	return false;
}


function showWfsKml (geometryIndex) {
	wfsKmlWindow = open("", "wfsattributes", "width="+wfsWindowWidth+", height="+wfsWindowHeight+", resizable, dependent=yes, scrollbars=yes");
	wfsKmlWindow.document.open("text/html");
	wfsKmlWindow.document.writeln("<html><head></head><body><div id='linkToKml'></div><div id='elementForm'></div></body></html>");
	wfsKmlWindow.document.close();
	
	str = "<form id = 'wmsKmlForm' onsubmit='return false;'><table>";

	var properties = d.get(geometryIndex).e;
	var propertyCount = properties.count();	
	for (var i = 0; i < propertyCount; i++) {
		var key = properties.getName(i);
		var value = properties.getValue(i);
		var expr = /Mapbender:/;
		if (!key.match(expr)) {
			str += "\t\t<tr>\n";
			str += "\t\t\t<td>\n\t\t\t\t<div>" + key + "</div>\n\t\t\t</td>\n";
			str += "\t\t\t<td>\n";
			str += "\t\t\t\t<input id = 'wmskml_" + i + "' name='" + key + "' type='text' size=20 value = '" + value + "'>\n";
			str += "\t\t\t</td>\n\t\t</tr>\n";
		}
	}	

	var updateOnClickText = "this.disabled=true;window.opener.updateKmlInDb("+geometryIndex+", 'update');";
	var deleteOnClickText = "var deltrans = confirm('This geometry will be removed from the KML.');";
	deleteOnClickText += "if (deltrans){";
	deleteOnClickText += "this.disabled=true;window.opener.updateKmlInDb("+geometryIndex+", 'delete')}";
	
	str += "\t\t\t<td><input type='button' name='updateButton' value='Update' onclick=\""+updateOnClickText+"\"/></td>\n";
// delete button not yet implemented
//	str += "\t\t\t<td><input type='button' name='deleteButton' value='Delete' onclick=\""+deleteOnClickText+"\"/></td>\n";
	str += "\t\t\t<td><input type='button' name='abortButton' value='Abort' onclick=\"window.close();\" /></td>\n";

	str += "\t\t</tr>\n";
	str += "\t</table>\n";
	str += "</form>\n";

	wfsKmlWindow.document.getElementById("elementForm").innerHTML = str;
}

//
// this method opens a new window and displays the attributes in wfs_conf
//
function showWfs(geometryIndex) {
	wfsConf = parent.get_complete_wfs_conf();

	wfsWindow = open("", "wfsattributes", "width="+wfsWindowWidth+", height="+wfsWindowHeight+", resizable, dependent=yes, scrollbars=yes");
	wfsWindow.document.open("text/html");

	var str = "";
	var strStyle = "";
	var defaultIndex = -1;

	str += "<form id='wfs'>\n";

	//
	// 1. add select box 
	//

	var onChangeText = "document.getElementById('elementForm').innerHTML = ";
	onChangeText += "window.opener.buildElementForm(this.value , " + geometryIndex + ");";
	onChangeText += "window.opener.setWfsWindowStyle(this.value);";
	
	str += "\t<select name='wfs' size='" + wfsConf.length + "'";
	str += " onChange=\""+ onChangeText +"\"";
	str += ">\n\t\t";

	var wfsConfIndices = getAvailableWfsForGeom(d.get(geometryIndex), wfsConf);
//	alert(wfsConfIndices.join(","));
	var selected = false;
	for (var i = 0; i < wfsConfIndices.length ; i++) {
		str += "<option value='" + wfsConfIndices[i] + "'";
		if (!selected) {
			str += " selected";
			selected = true;
			defaultIndex = parseInt(wfsConfIndices[i]);
		}
		str += ">" + wfsConf[wfsConfIndices[i]]['wfs_conf_abstract'];
		str += "</option>\n\t\t";
	}

	
	str += "</select>\n\t\t</form>\n\t";
	str += "<div id='elementForm'>\n</div>";
	
	if (defaultIndex != -1) {
		wfsWindow.document.writeln("<html><head><style type='text/css'>"+wfsConf[defaultIndex]['g_style']+"</style></head><body></body></html>");
		wfsWindow.document.write(str);
		wfsWindow.document.close();
		wfsWindow.document.getElementById("elementForm").innerHTML = buildElementForm(defaultIndex, geometryIndex);
	}
	else {
		wfsWindow.document.writeln("<html><head><style type='text/css'></style></head><body></body></html>");
		wfsWindow.document.write(str);
		wfsWindow.document.close();
	}
}

function setWfsWindowStyle(wfsConfIndex) {
	wfsWindow.document.getElementsByTagName("style")[0].innerHTML = wfsConf[wfsConfIndex]['g_style'];
}

// returns a form with the elements of a selected wfs
// (if the original wfs is the selected wfs, the values are set too)
function buildElementForm(wfsConfIndex, memberIndex){
	var featureTypeMismatch = false;
	if (parseInt(d.get(memberIndex).wfs_conf) != parseInt(wfsConfIndex)) {featureTypeMismatch = true;}
	var str = "";
	var hasGeometryColumn = false;
	var featureTypeArray = wfsConf[wfsConfIndex];
	var memberElements;
	var fid = false;

	if (!featureTypeMismatch) {
		memberElements = d.get(memberIndex).e;
		fid = memberElements.getElementValueByName('fid');
	}
	
	if (typeof(featureTypeArray["element"]) !== "undefined") {

		str += "<form id='"+featureTypeElementFormId+"'>\n\t<table>\n";
		featureTypeElementArray = featureTypeArray["element"];
		
		//
		// 2. add rows to form 
		//
		for (var i = 0 ; i < featureTypeElementArray.length ; i ++) {
			var featureTypeElement = featureTypeElementArray[i];

			var elementName = featureTypeElement['element_name'];
			var elementType = featureTypeElement['element_type'];
			var isEditable = (parseInt(featureTypeElement['f_edit']) == 1); 
			var isMandatory = (parseInt(featureTypeElement['f_mandatory']) == 1); 
			var isGeomColumn = (parseInt(featureTypeElement['f_geom']) == 1); 

			var elementLabelExists = (featureTypeElement['f_label'] != "");
			var elementLabel = ""; 
			if (elementLabelExists) {
				elementLabel = featureTypeElement['f_label'];
			}
			var elementLabelStyle = featureTypeElement['f_label_id'];

			if (!isGeomColumn) {
				if (isEditable) {
					str += "\t\t<tr>\n";
					str += "\t\t\t<td>\n\t\t\t\t<div class = '"+elementLabelStyle+"''>" + elementLabel + "</div>\n\t\t\t</td>\n";
					str += "\t\t\t<td>\n";

					var elementValue = "";
					if (!featureTypeMismatch) {
						for (var j = 0 ; j < memberElements.count() ; j ++) {
							if (memberElements.getName(j) == featureTypeElement['element_name']) {
								elementValue = memberElements.getValue(j);
							}
						}
					}
					var formElementHtml = featureTypeElement['f_form_element_html']; 
					if (!formElementHtml || !formElementHtml.match(/<select/)) {
						str += "\t\t\t\t<input id = 'datatype_" + elementName + "' name='datatype' type='hidden' value = '" + elementType + "'>\n";
						str += "\t\t\t\t<input id = 'mandatory_" + elementName + "' name='mandatory' type='hidden' value = '" + isMandatory + "'>\n";
						str += "\t\t\t\t<input id = '" + elementName + "' name='" + elementLabel + "' type='text' class = '"+featureTypeElement['f_style_id']+"' size=20 value = '" + elementValue + "'>\n";
					}
					else {
							while (formElementHtml.match(/\\/)) {
								formElementHtml = formElementHtml.replace(/\\/, "");
							} 
							// preselect the correct entry of the box
							var patternString = "option value( )*=( )*'"+elementValue+"'";
							var pattern = new RegExp(patternString);
							var patternStringForReplace = "option value = '"+elementValue+"'";
							formElementHtml = formElementHtml.replace(pattern, patternStringForReplace+" selected");
							str += formElementHtml;
					}
					str += "\t\t\t</td>\n\t\t</tr>\n";
				}
			}
			else {
				hasGeometryColumn = true;
			}
		}

		//
		// 3. add buttons "save", "update", "delete"
		//
		str += "</table><table>";
		var isTransactional = (featureTypeArray['wfs_transaction']); 
		if (isTransactional) {
			str += "\t\t<tr>\n";

			var options = ["save", "update", "delete", "abort"];
			for (var i = 0 ; i < options.length ; i++) {
				var onClickText = "this.disabled=true;var result = window.opener.formCorrect(document, '"+featureTypeElementFormId+"');";
				onClickText += 	"if (result.isCorrect) {";
				onClickText += 		"window.opener.dbGeom('"+options[i]+"', "+memberIndex+"); ";
//				onClickText +=      "window.close();";
				onClickText += 	"}";
				onClickText += 	"else {";
				onClickText += 		"alert(result.errorMessage);this.disabled=false;"
				onClickText += 	"}";
				
				if (options[i] == "save" && hasGeometryColumn && (!fid || showSaveButtonForExistingGeometries)) {
					str += "\t\t\t<td><input type='button' name='saveButton' value='"+msgObj.buttonLabelSaveGeometry+"' onclick=\""+onClickText+"\" /></td>\n";
				}
				
				if (!featureTypeMismatch && fid) {
					if (options[i] == "update" && hasGeometryColumn) {
						str += "\t\t\t<td><input type='button' name='updateButton' value='"+msgObj.buttonLabelUpdateGeometry+"' onclick=\""+onClickText+"\"/></td>\n";
					}
					if (options[i] == "delete"){ 
						var deleteOnClickText = "var deltrans = confirm('"+msgObj.messageConfirmDeleteGeomFromDb+"');";
						deleteOnClickText += "if (deltrans){";
						deleteOnClickText += onClickText + "}";
						str += "\t\t\t<td><input type='button' name='deleteButton' value='"+msgObj.buttonLabelDeleteGeometry+"' onclick=\""+deleteOnClickText+"\"/></td>\n";
					}
				}
				if (options[i] == "abort") {
					str += "\t\t\t<td><input type='button' name='abortButton' value='"+msgObj.buttonLabelAbort+"' onclick=\"window.close();\" /></td>\n";
				}
			}
			str += "\t\t</tr>\n";
		}
		str += "\t</table>\n";
		str += "<input type='hidden' id='fid' value='"+fid+"'>";
//			str += "<input type='text' name='mb_wfs_conf'>";
		str += "</form>\n";
	}
	return str;
}

function dbGeom(type,m) {
	if (typeof(wfsWindow) != 'undefined' && !wfsWindow.closed) {
		d.get(m).wfs_conf = parseInt(wfsWindow.document.forms[0].wfs.options[wfsWindow.document.forms[0].wfs.selectedIndex].value);
		d.get(m).e = new parent.Wfs_element();
	}
	else {
		wfsConf = parent.get_complete_wfs_conf();
	}
	var myconf = wfsConf[d.get(m).wfs_conf];
	
	var mapObjInd = parent.getMapObjIndexByName(mod_digitize_target);

	if (myconf['featuretype_srs'] != parent.mb_mapObj[mapObjInd].epsg) {
		alert(msgObj.errorMessageEpsgMismatch + parent.mb_mapObj[mapObjInd].epsg + " / "+ myconf['featuretype_srs']);
	}
	else {
		var fid = false;
		var errorMessage = "";
		if (typeof(wfsWindow) != 'undefined' && !wfsWindow.closed) {
			myform = wfsWindow.document.getElementById(featureTypeElementFormId);
		
			for (var i=0; i<myform.length; i++){
				if (myform.elements[i].id == "fid") {
					fid = myform.elements[i].value;
					if (fid == "false") {
						fid = false;					
					}
					else {
						d.get(m).e.setElement('fid', fid);
					}
				}
				else if (myform.elements[i].type == 'text' ){
					if (myform.elements[i].id) {
						d.get(m).e.setElement(myform.elements[i].id, myform.elements[i].value);
					}
					else {
						errorMessage = msgObj.messageErrorFormEvaluation;
					}
				}
				// selectbox
				else if (typeof(myform.elements[i].selectedIndex) == 'number') {
					if (myform.elements[i].id) {
						d.get(m).e.setElement(myform.elements[i].id, myform.elements[i].options[myform.elements[i].selectedIndex].value);
					}
					else {
						errorMessage = msgObj.messageErrorFormEvaluation;
					}
				}
			}
		}
		else {
			fid = d.get(m).e.getElementValueByName('fid');
		}
		str = parent.get_wfs_str(myconf, d, m, type, fid);
		
		parent.mb_ajax_post("../extensions/geom2wfst.php", {'filter':str,'url':myconf['wfs_transaction'],'featuretype_name':myconf['featuretype_name'],'wfs_conf_id':wfsConf[d.get(m).wfs_conf]['wfs_conf_id']}, function(json,status){
			var result = eval('('+json+')');
			var response = result.response;
			var fid = result.fid;
			wfsSubWrite(m, type, status, response, fid);
		});
	}
}

function wfsSubWrite(m, type, status, response, fid) {
	if (status == "success" && response == "success") {
		if (type == 'save' && fid) {
			d.get(m).e.setElement("fid", fid);
		}
		if (type == 'delete') {
			parent.mb_disableThisButton(mod_digitizeEvent);
			d.del(m);
		}

		var wfsWriteMessage = msgObj.messageSuccessWfsWrite;
	}
	else {
		var wfsWriteMessage = msgObj.messageErrorWfsWrite;
	} 
	parent.mb_execWfsWriteSubFunctions();
	executeDigitizeSubFunctions();
	

	if (typeof(wfsWindow) != 'undefined' && !wfsWindow.closed) {
		wfsWindow.alert(wfsWriteMessage);
		window.setTimeout("wfsWindow.close()",0);
	}
	else {
		alert(wfsWriteMessage);
	}
}
function getMultiGeometryIdsByPlacemarkId (placemarkId) {
	var multiGeometryIdArray = [];
	for (var i = 0; i < d.count(); i++) {
		var currentPlacemarkId = d.get(i).e.getElementValueByName("Mapbender:placemarkId");
		if (currentPlacemarkId && currentPlacemarkId == placemarkId) {
			multiGeometryIdArray.push(i);	
		}
	}	
	return multiGeometryIdArray;
}

function updateKmlInDb (geometryIndex, command) {
	var properties = d.get(geometryIndex).e;
	var placemarkId = properties.getElementValueByName("Mapbender:placemarkId");
	
	var multiGeometryIdArray = getMultiGeometryIdsByPlacemarkId(placemarkId);

	if (typeof(wfsKmlWindow) != 'undefined' && !wfsKmlWindow.closed) {

		// update properties from form
		myform = wfsKmlWindow.document.getElementById("wmsKmlForm");
	
		for (var i=0; i < myform.length; i++){
			if (myform.elements[i].type == 'text' ){
				if (myform.elements[i].id) {
					var key = myform.elements[i].name;
					var value = myform.elements[i].value;
					
					// update all geometries with the same placemark id
					for (var j = 0; j < multiGeometryIdArray.length; j++) {
						var currentProperties = d.get(j).e; 
						currentProperties.setElement(key, value);
					}
				}
			}
		}
		var kmlId = properties.getElementValueByName("Mapbender:id");
	
		parent.mb_ajax_post("../php/mod_updateKmlInDb.php", {command:command, kmlId:kmlId, placemarkId:placemarkId, geoJSON:d.placemarkToString(placemarkId)}, function(obj, status) {
			if (obj === "1") {
				wfsKmlWindow.alert("KML updated.");
				var link = wfsKmlWindow.document.createElement("a");
				link.href = "../php/mod_displayKML.php?kmlId=" + kmlId;
				link.target = "_blank";
				link.innerHTML = "KML";
				wfsKmlWindow.document.getElementById('elementForm').innerHTML = "";
				wfsKmlWindow.document.getElementById('linkToKml').appendChild(link);
			}
			else {
				wfsKmlWindow.alert("Error, KML could not be updated. Check your error log.");
			}
		});
	}
}


// --- wfs window (begin) -----------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------------

function getMessages() {
	parent.mb_ajax_json("../php/mod_digitize_messages.php", function(obj, status) {
		msgObj = obj;
		applyMessages();
	});
}

function applyMessages() {
	updateMeasureTag();
	updateListOfGeometries();
	updateButtons();
}

	</script>
	</head>
	<body onload="registerFunctions();displayButtons();">
		<table cellpadding='0' cellspacing='0' align = center><tr><td><div id='digButtons'></div></td></tr></table>
		<div id = 'listOfGeometries'></div>
	</body>
</html>
-------------- next part --------------
<?php
#$Id: mod_wfs_SpatialRequest.php 3271 2008-12-08 10:05:31Z christoph $
#$Header: /cvsroot/mapbender/mapbender/http/javascripts/mod_wfs_spatialRequest.php,v 1.4 2006/03/08 15:26:26 c_baudson Exp $
# Copyright (C) 2002 CCGIS
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

require_once(dirname(__FILE__)."/../php/mb_validatePermission.php");
$wfs_conf_filename = "wfs_default.conf";
include '../include/dyn_php.php';
$fname = dirname(__FILE__) . "/../../conf/" . $wfs_conf_filename;
if (file_exists($fname)) {
	include($fname);
}
else {
	$e = new mb_exception("mod_wfs_SpatialRequest.php: Configuration file " . $wfs_conf_filename . " not found.");
}

include '../include/dyn_js.php';
echo "var mod_wfs_spatialRequest_target = '".$e_target[0]."';\n";
?>
//element var openLinkFromSearch for opening attribute link directly onclick of searchResult entry
try{
	if (openLinkFromSearch){}
}
catch(e){
	openLinkFromSearch =0;
}

var wfsAreaType_point = "point";
var wfsAreaType_polygon = "polygon";
var wfsAreaType_rectangle = "rectangle";
var wfsAreaType_extent = "extent";
var wfsAreaType_current = "";

var mod_wfs_spatialRequest_frameName = "";
var mod_wfs_spatialRequest_epsg;
var mod_wfs_spatialRequest_width;
var mod_wfs_spatialRequest_height;

var mod_wfs_spatialRequest_bg = "";
var mod_wfs_spatialRequest_pgsql = true;
var mod_wfs_spatialRequest_win = null;
var mod_wfs_spatialRequest_thema = false;

var button_point = "point";
var button_polygon = "polygon";
var button_rectangle = "rectangle";
var button_extent = "extent";
var button_dialogue = "dialogue";

var activeButton = null;
var mod_wfs_spatialRequest_geometry = null;
var mod_wfs_spatialRequestSubFunctions = [];

var buttonWfs_id = [];
var buttonWfs_on = [];
var buttonWfs_src = [];
var buttonWfs_title_off = [];
var buttonWfs_title_on = [];
var buttonWfs_x = [];
var buttonWfs_y = [];

var numberOfAjaxCalls = 0;
var numberOfFinishedAjaxCalls = 0;
var resultGeometryPopup;
var _geomArray = new GeometryArray();
try {if(mod_digitize_elName){}}catch(e) {mod_digitize_elName = "digitize";}

function addButtonWfs(id, isOn, src, title, x, y) {
	buttonWfs_id.push(id);
	buttonWfs_on.push(isOn);
	buttonWfs_src.push(src);
	buttonWfs_title_off.push(title);
	buttonWfs_title_on.push(title);
	buttonWfs_x.push(x);
	buttonWfs_y.push(y);
}

var msgObj;

mb_registerInitFunctions("init_wfsSpatialRequest()");
//mb_registerL10nFunctions("init_wfsSpatialRequest()");

function init_wfsSpatialRequest() {
	mb_ajax_json("../php/mod_wfsSpatialRequest_messages.php", function(obj, status) {
		msgObj = obj;
		buttonWfs_id = [];
		buttonWfs_on = [];
		buttonWfs_src = [];
		buttonWfs_title_off = [];
		buttonWfs_title_on = [];
		buttonWfs_x = [];
		buttonWfs_y = [];
		addButtonWfs("rectangle", buttonRectangle.status, buttonRectangle.img, msgObj.buttonLabelRectangle, buttonRectangle.x, buttonRectangle.y);
		addButtonWfs("polygon", buttonPolygon.status, buttonPolygon.img, msgObj.buttonLabelPolygon, buttonPolygon.x, buttonPolygon.y);
		addButtonWfs("point", buttonPoint.status, buttonPoint.img, msgObj.buttonLabelPoint, buttonPoint.x, buttonPoint.y);
		addButtonWfs("extent", buttonExtent.status, buttonExtent.img, msgObj.buttonLabelExtent, buttonExtent.x, buttonExtent.y);
		addButtonWfs("dialogue", buttonDialogue.status, buttonDialogue.img, msgObj.buttonLabelDialogue, buttonDialogue.x, buttonDialogue.y);
		displayButtons();
	});
}
// ------------------------------------------------------------------------------------------
// ------------ button handling -------------------------------------------------------------

function wfsInitFunction (j) {
	var functionCall = "mb_regButton_frame('initWfsButton', null, "+j+")";
	var x = new Function ("", functionCall);
	x();
}

function displayButtons() {
	for (var i = 0 ; i < buttonWfs_id.length ; i ++) {
		if (parseInt(buttonWfs_on[i])==1) {
			var currentDiv = document.createElement("div");
			currentDiv.id = buttonWfs_id[i]+"Div";
			currentDiv.style.position = "absolute";
			currentDiv.style.left = buttonWfs_x[i]
			currentDiv.style.top = buttonWfs_y[i];
			currentDiv.style.zIndex = buttonWfs_zIndex;

			var currentImg = document.createElement("img");
			currentImg.id = buttonWfs_id[i];
			currentImg.name = buttonWfs_id[i];
			currentImg.title = buttonWfs_title_off[i];
			currentImg.src = buttonWfs_imgdir+buttonWfs_src[i];
			currentImg.onmouseover = new Function("wfsInitFunction("+i+")");

			currentDiv.appendChild(currentImg);
			document.getElementsByTagName('body')[0].appendChild(currentDiv);
		}
	}
}

function initWfsButton(ind, pos) {
	mb_button[ind] = document.getElementById(buttonWfs_id[pos]);
	mb_button[ind].img_over = buttonWfs_imgdir + buttonWfs_src[pos].replace(/_off/,"_over");
	mb_button[ind].img_on = buttonWfs_imgdir + buttonWfs_src[pos].replace(/_off/,"_on");
	mb_button[ind].img_off = buttonWfs_imgdir + buttonWfs_src[pos];
	mb_button[ind].status = 0;
	mb_button[ind].elName = buttonWfs_id[pos];
	mb_button[ind].fName = "";
	mb_button[ind].go = new Function ("wfsEnable(mb_button["+ind+"], " + pos + ")");
	mb_button[ind].stop = new Function ("wfsDisable(mb_button["+ind+"], " + pos + ")");
	var ind = getMapObjIndexByName(mod_wfs_spatialRequest_target);
	mod_wfs_spatialRequest_width = mb_mapObj[ind].width;
	mod_wfs_spatialRequest_height = mb_mapObj[ind].height;
	mod_wfs_spatialRequest_epsg = mb_mapObj[ind].epsg;
	mb_registerSubFunctions("drawDashedLineExt()");
	mb_registerPanSubElement("measuring");
}

function wfsEnable(obj) {
   	var el = window.frames[mod_wfs_spatialRequest_target].document;
   	el.onmouseover = null;
   	el.onmousedown = null;
   	el.onmouseup = null;
   	el.onmousemove = null;

	if (obj.id == button_point) {
		if (activeButton == null) {
			activeButton = obj;
		}
		mod_wfs_spatialRequest_geometry = new Geometry(geomType.point);
		wfsAreaType_current = wfsAreaType_point;
		mod_wfs_spatialRequest_digitize_go(geomType.point);
	}
	if (obj.id == button_polygon) {
		if (activeButton == null) {
			activeButton = obj;
		}
		mod_wfs_spatialRequest_geometry = new Geometry(geomType.polygon);
		wfsAreaType_current = wfsAreaType_polygon;
		mod_wfs_spatialRequest_digitize_go(geomType.polygon);
		var measureSub = "";
		for(var i=0; i<mod_wfs_spatialRequestSubFunctions.length; i++){
			measureSub += eval(mod_wfs_spatialRequestSubFunctions[i]);
		}
		writeTag(mod_wfs_spatialRequest_target,"measure_sub",measureSub);
	}
	else if (obj.id == button_rectangle){
		if (activeButton == null) {
			activeButton = obj;
		}
		mod_wfs_spatialRequest_geometry = new Geometry(geomType.line);
		wfsAreaType_current = wfsAreaType_rectangle;
		mod_selAreaExt_click();
	}
	else if (obj.id == button_extent){
		if (activeButton == null) {
			activeButton = obj;
		}
		mod_wfs_spatialRequest_geometry = new Geometry(geomType.line);
		wfsAreaType_current = wfsAreaType_extent;
		var ind = getMapObjIndexByName(mod_wfs_spatialRequest_target);
		var p0 = mapToReal(mod_wfs_spatialRequest_target, new Point(0,0));
		var p1 = mapToReal(mod_wfs_spatialRequest_target, new Point(mb_mapObj[ind].width,mb_mapObj[ind].height));
		mod_wfs_spatialRequest_geometry.addPoint(p0);
		mod_wfs_spatialRequest_geometry.addPoint(p1);
		mod_getAreaExt_send();
	}
	else if (obj.id == button_dialogue) {
		activeButton = obj;
		mod_wfs_SpatialRequest_dialog();
	}
}

function wfsDisable(obj) {
	var el = window.frames[mod_wfs_spatialRequest_target].document;
	el.onmousedown = null;
	el.ondblclick = null;
	el.onmousemove = null;
	writeTag(mod_wfs_spatialRequest_target,"measure_display","");
	writeTag(mod_wfs_spatialRequest_target,"measure_sub","");
	activeButton = null;
}

// ------------------------------------------------------------------------------------------

// ----------------------------------------------------------------------------------------------
// -------------------- rectangle -----------------------------------------------------------------

function mod_selAreaExt_click(){
   var el = window.frames[mod_wfs_spatialRequest_target].document;
   el.onmouseover = mod_selAreaExt_init;
   el.onmousedown = mod_box_start;
   el.onmouseup = mod_selAreaExt_get;
   el.onmousemove = mod_box_run;
}
function mod_selAreaExt_init(e){
   mb_isBF = mod_wfs_spatialRequest_target;
   mb_zF = mod_wfs_spatialRequest_target;
}
function mod_selAreaExt_get(e){
	mod_selAreaExt_setValidClipping(mod_box_stop(e));
	mb_isBF = mod_wfs_spatialRequest_target;
	mb_zF = mod_wfs_spatialRequest_target;
}
function mod_selAreaExt_setValidClipping(coords){
	if (mod_wfs_spatialRequest_geometry != null) {
		mod_wfs_spatialRequest_geometry.addPoint(new Point(coords[0],coords[1]));
		mod_wfs_spatialRequest_geometry.addPoint(new Point(coords[2],coords[3]));

		if(mod_wfs_spatialRequest_geometry.count() == 2){
			mod_getAreaExt_send();
		}
		else{
			alert(errorMessageInvalidExtent[selectedLanguage]);
			mb_disableThisButton(activeButton.id);
		}
	}
}
// ----------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------
// -------------------- polygon && point --------------------------------------------------------

function mod_wfs_spatialRequest_digitize_go(geomType){
	if (geomType == geomType.polygon) {
		mod_wfs_spatialRequest_geometry = new Geometry(geomType.polygon);
	}
	s = new Snapping(mod_wfs_spatialRequest_target);

	var el = window.frames[mod_wfs_spatialRequest_target].document;
	el.onmousedown = mod_wfs_spatialRequest_start;
	el.onmousemove = mod_wfs_spatialRequest_run;
	var measureSub = "";
	for(var i=0; i<mod_wfs_spatialRequestSubFunctions.length; i++){
		measureSub += eval(mod_wfs_spatialRequestSubFunctions[i]);
	}
	writeTag(mod_wfs_spatialRequest_target,"measure_sub",measureSub);
}

// ---------------------------------------------------------------------------------------------

function mod_wfs_spatialRequest_run(e) {
	if (mod_wfs_spatialRequest_geometry.count() >= 3) {
		mb_getMousePos(e,mod_wfs_spatialRequest_target);
		var pos = new Point(clickX,clickY);
		s.check(pos);
	}
}

function mod_wfs_spatialRequest_start(e){
	var realWorldPos;
	if (s.isSnapped() == true) {
		realWorldPos = s.getSnappedPoint();
		s.clean();
	}
	else {
		mb_getMousePos(e,mod_wfs_spatialRequest_target);
		realWorldPos = mapToReal(mod_wfs_spatialRequest_target,new Point(clickX,clickY));
	}

	mod_wfs_spatialRequest_geometry.addPoint(realWorldPos);

	if (mod_wfs_spatialRequest_geometry.count() == 1) {
		s.add(mod_wfs_spatialRequest_geometry.get(0));
	}
	if (s.isSnapped() && mod_wfs_spatialRequest_geometry.count() >= 3 && mod_wfs_spatialRequest_geometry.get(-1).equals(mod_wfs_spatialRequest_geometry.get(0))) {
		mod_wfs_spatialRequest_geometry.close();
		mod_getAreaExt_send();
		return;
	}

	if(wfsAreaType_current == wfsAreaType_point){
		mod_getAreaExt_send();
		return;
	}
	drawDashedLineExt();
}
function drawDashedLineExt(){
	var str_mPoints = "<div style='position:absolute;left:0px;top:0px' ><img src='"+mb_trans.src+"' width='"+mod_wfs_spatialRequest_width+"' height='0'></div>";
	str_mPoints += "<div style='position:absolute;left:0px;top:0px' ><img src='"+mb_trans.src+"' width='0' height='"+mod_wfs_spatialRequest_height+"'></div>";
	if (mod_wfs_spatialRequest_geometry != null) {
		for(var i=0; i<mod_wfs_spatialRequest_geometry.count(); i++){
			var pos = realToMap(mod_wfs_spatialRequest_target,mod_wfs_spatialRequest_geometry.get(i));
			str_mPoints += "<div style='font-size:1px;position:absolute;top:"+(pos.y-2)+"px;left:"+(pos.x-2)+"px;width:3px;height:3px;background-color:#ff0000'></div>";
		}
		if(mod_wfs_spatialRequest_geometry.count()>1){
			for(var k=1; k<mod_wfs_spatialRequest_geometry.count(); k++){
				var pos0 = realToMap(mod_wfs_spatialRequest_target,mod_wfs_spatialRequest_geometry.get(k));
				var pos1 = realToMap(mod_wfs_spatialRequest_target,mod_wfs_spatialRequest_geometry.get(k-1));
				str_mPoints += evaluateDashesExt(pos1,pos0,k);
			}
		}
	}
	writeTag(mod_wfs_spatialRequest_target,"measuring",str_mPoints);
}
function evaluateDashesExt(p1,p0,count){
	var str_dashedLine = "";
	var d = p0.dist(p1);
	var n = Math.round(d);
	var s =  p0.minus(p1).dividedBy(n);
	for(var i=1; i<n; i++){
		var currPoint = p1.plus(s.times(i)).minus(new Point(2,2)).round(0);
		if(currPoint.x >= 0 && currPoint.x <= mod_wfs_spatialRequest_width && currPoint.y >= 0 && currPoint.y <= mod_wfs_spatialRequest_height){
			str_dashedLine += "<div style='font-size:1px;position:absolute;top:"+currPoint.y+"px;left:"+currPoint.x+"px;width:3px;height:3px;background-color:#ff0000'></div>";
		}
	}
	return str_dashedLine;
}
function mod_wfs_spatialRequest_close(){
	if(mod_wfs_spatialRequest_geometry.count() < 3){
		return;
	}
	mod_wfs_spatialRequest_geometry.closeGeometry();
	drawDashedLineExt();
	mod_getAreaExt_send();
}

function register_setExtRequestSubFunctions(stringFunction){
	mod_wfs_spatialRequestSubFunctions[mod_wfs_spatialRequestSubFunctions.length] = stringFunction;
}

function mod_getAreaExt_send(){
	mb_setwfsrequest(mod_wfs_spatialRequest_target,mod_wfs_spatialRequest_geometry);
	mod_wfs_spatialRequest_delete();
	mb_disableThisButton(activeButton.id);
	mod_wfs_spatialRequest_geometry = null;
}

function mod_wfs_spatialRequest_delete(){
	writeTag(mod_wfs_spatialRequest_target,"measuring","");
	writeTag(mod_wfs_spatialRequest_target,"measure_display","");
}

function mod_wfs_spatialRequest_timeout(){
	var el = window.frames[mod_wfs_spatialRequest_target].document;
	el.onmousedown = null;
	el.ondblclick = null;
	el.onmousemove = null;
}

function mod_wfs_spatialRequest_disableTimeout(){
	var el = window.frames[mod_wfs_spatialRequest_target].document;
	el.onmousedown = mod_wfs_spatialRequest_start;
}

function isSetWfsResultToDigitize() {
	if (parseInt(buttonWfs_toDigitize_on)==1) return true;
	return false;
}

function mod_wfs_SpatialRequest_dialog(){
	if(!mod_wfs_spatialRequest_win || mod_wfs_spatialRequest_win == null || mod_wfs_spatialRequest_win.closed == true){
		mod_wfs_spatialRequest_win = window.open("","mod_wfs_spatialRequest_win","width=200,height=150,resizable=yes");
		mod_wfs_spatialRequest_win.document.open("text/html");

		mod_wfs_spatialRequest_win.document.writeln('<script language="JavaScript" type="text/javascript">');
		mod_wfs_spatialRequest_win.document.writeln('function set(obj){');
		mod_wfs_spatialRequest_win.document.writeln('for(var i=0; i< document.getElementsByName("geom").length; i++){');
		mod_wfs_spatialRequest_win.document.writeln('if(document.getElementsByName("geom")[i].checked){');
		mod_wfs_spatialRequest_win.document.writeln('window.opener.mod_setExtRequest_geom = document.getElementsByName("geom")[i].value;');
		mod_wfs_spatialRequest_win.document.writeln('}');
		mod_wfs_spatialRequest_win.document.writeln('}');
		mod_wfs_spatialRequest_win.document.writeln('window.opener.wfsEnable(obj);');
		mod_wfs_spatialRequest_win.document.writeln('window.close();');
		mod_wfs_spatialRequest_win.document.writeln('return false;	');
		mod_wfs_spatialRequest_win.document.writeln('}');
		mod_wfs_spatialRequest_win.document.writeln('</script>');

		mod_wfs_spatialRequest_win.document.writeln("<form>");
		mod_wfs_spatialRequest_win.document.writeln("<input id='point' name='geom' type='radio' value='"+button_point+"' onclick='set(this)'> Punkt<br>");
		mod_wfs_spatialRequest_win.document.writeln("<input id='rectangle' name='geom' type='radio' value='"+button_rectangle+"' onclick='set(this)'> Rechteck<br>");
		mod_wfs_spatialRequest_win.document.writeln("<input id='polygon' name='geom' type='radio' value='"+button_polygon+"'onclick='set(this)'> Polygon<br>");
		mod_wfs_spatialRequest_win.document.writeln("<input id='extent' name='geom' type='radio' value='"+button_extent+"'onclick='set(this)'> Extent<br>");
		var checked = "";
		mod_wfs_spatialRequest_win.document.writeln("</form>");
		mod_wfs_spatialRequest_win.document.close();
	}
	else{
		mod_wfs_spatialRequest_win.focus();
	}
}

function mb_setwfsrequest(target,queryGeom){
	if (typeof(wfsPopup) != "undefined") {
		wfsPopup.hide();
	}
	//mb_wfs_reset();
	var ind = getMapObjIndexByName(target);
	var db_wfs_conf_id = [];
	js_wfs_conf_id = [];
	_geomArray = new GeometryArray();

	if (typeof(resultGeometryPopup) != "undefined") {
		resultGeometryPopup.hide();
	}

	wfs_config = window.frames["wfs_conf"].get_wfs_conf();
	for (var i=0; i<mb_mapObj[ind].wms.length; i++){
		for(var ii=0; ii<mb_mapObj[ind].wms[i].objLayer.length; ii++){
			var o = mb_mapObj[ind].wms[i].objLayer[ii];
			if(o.gui_layer_wfs_featuretype != '' && o.gui_layer_visible == '1'){
				// db_wfs_conf_id entries have to be unique
				var exists = false;
				for (var iii = 0; iii < db_wfs_conf_id.length; iii++) {
					if (db_wfs_conf_id[iii] == o.gui_layer_wfs_featuretype) {
						exists = true;
						break;
					}
				}	
				if (!exists) {
					db_wfs_conf_id[db_wfs_conf_id.length] = o.gui_layer_wfs_featuretype;
				}
			}
		}
	}
	for(var i=0; i<db_wfs_conf_id.length; i++){
		for(var ii in wfs_config){
			if(wfs_config[ii]['wfs_conf_id'] == db_wfs_conf_id[i]) {

				// js_wfs_conf_id entries have to be unique
				var exists = false;
				for (var iii = 0; iii < js_wfs_conf_id.length; iii++) {
					var n = js_wfs_conf_id[iii];
					if (wfs_config[ii]['wfs_conf_id'] == wfs_config[n]['wfs_conf_id']) {
						exists = true;
						break;
					}
				}	
				if (!exists) {
					js_wfs_conf_id[js_wfs_conf_id.length] = ii;
				}
			}
		}
	}

	numberOfAjaxCalls =  js_wfs_conf_id.length;

	if(queryGeom.geomType==geomType.polygon){
		for(var i=0; i<js_wfs_conf_id.length; i++){
			var srs = wfs_config[js_wfs_conf_id[i]]['featuretype_srs'];
			var url = wfs_config[js_wfs_conf_id[i]]['wfs_getfeature'];
			url += mb_getConjunctionCharacter(wfs_config[js_wfs_conf_id[i]]['wfs_getfeature']);
			url += "service=wfs&request=getFeature&version=1.0.0";
			url += "&typename="+ wfs_config[js_wfs_conf_id[i]]['featuretype_name'];
			url += "&filter=";
			var filter = "<ogc:Filter xmlns:ogc=\"http://ogc.org\" xmlns:gml=\"http://www.opengis.net/gml\">";

			if(buttonPolygon.filteroption=='within'){
				filter += "<Within><ogc:PropertyName>";
				for(var j=0; j<wfs_config[js_wfs_conf_id[i]]['element'].length; j++){
					if(wfs_config[js_wfs_conf_id[i]]['element'][j]['f_geom'] == 1){
						filter += wfs_config[js_wfs_conf_id[i]]['element'][j]['element_name'];
					}
				}
				filter += "</ogc:PropertyName><gml:Polygon srsName=\""+srs+"\">";
				filter += "<gml:outerBoundaryIs><gml:LinearRing><gml:coordinates>";
				for(var k=0; k<queryGeom.count(); k++){
					if(k>0)	filter += " ";
					filter += queryGeom.get(k).x+","+queryGeom.get(k).y;
				}
				filter += "</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs>";
				filter += "</gml:Polygon></Within>";
			}
			else if(buttonPolygon.filteroption=='intersects'){
				filter += "<Intersects><ogc:PropertyName>";
				for(var j=0; j<wfs_config[js_wfs_conf_id[i]]['element'].length; j++){
					if(wfs_config[js_wfs_conf_id[i]]['element'][j]['f_geom'] == 1){
						filter += wfs_config[js_wfs_conf_id[i]]['element'][j]['element_name'];
					}
				}
				filter += "</ogc:PropertyName><gml:Polygon srsName='"+srs+"'>";
				filter += "<gml:outerBoundaryIs><gml:LinearRing><gml:coordinates>";
				for(var k=0; k<queryGeom.count(); k++){
					if(k>0)	filter += " ";
					filter += queryGeom.get(k).x+","+queryGeom.get(k).y;
				}
				filter += "</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs>";
				filter += "</gml:Polygon></Intersects>";
			}

			filter += '</ogc:Filter>';
			mb_get_geom(url, filter, i, wfs_config[js_wfs_conf_id[i]]['featuretype_name'], js_wfs_conf_id[i], db_wfs_conf_id[i]);
		}
	}
	else if(queryGeom.geomType==geomType.line){
		var rectangle = [];
		if(queryGeom.geomType == geomType.line){
			var rectangle = queryGeom.getBBox();
		}
		for(var i=0; i<js_wfs_conf_id.length; i++){
			var srs = wfs_config[js_wfs_conf_id[i]]['featuretype_srs'];
			var url = wfs_config[js_wfs_conf_id[i]]['wfs_getfeature'];
			url += mb_getConjunctionCharacter(wfs_config[js_wfs_conf_id[i]]['wfs_getfeature']);
			param = "service=wfs&request=getFeature&version=1.0.0&typename="+ wfs_config[js_wfs_conf_id[i]]['featuretype_name']+"&filter=";
			var filter = "<ogc:Filter xmlns:ogc='http://ogc.org' xmlns:gml='http://www.opengis.net/gml'>";

			if(buttonRectangle.filteroption=='within'){
				filter += "<Within><ogc:PropertyName>";
				for(var j=0; j<wfs_config[js_wfs_conf_id[i]]['element'].length; j++){
					if(wfs_config[js_wfs_conf_id[i]]['element'][j]['f_geom'] == 1){
						filter += wfs_config[js_wfs_conf_id[i]]['element'][j]['element_name'];
					}
				}
				filter += "</ogc:PropertyName><gml:Polygon srsName='"+srs+"'>";
				filter += "<gml:outerBoundaryIs><gml:LinearRing><gml:coordinates>";
				filter += rectangle[0].x+","+rectangle[0].y;
				filter += " ";
				filter += rectangle[0].x+","+rectangle[1].y;
				filter += " ";
				filter += rectangle[1].x+","+rectangle[1].y;
				filter += " ";
				filter += rectangle[1].x+","+rectangle[0].y;
				filter += " ";
				filter += rectangle[0].x+","+rectangle[0].y;
				filter += "</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs>";
				filter += "</gml:Polygon></Within>";
			}
			else if(buttonRectangle.filteroption=='intersects'){
				filter += "<Intersects><ogc:PropertyName>";
				for(var j=0; j<wfs_config[js_wfs_conf_id[i]]['element'].length; j++){
					if(wfs_config[js_wfs_conf_id[i]]['element'][j]['f_geom'] == 1){
						filter += wfs_config[js_wfs_conf_id[i]]['element'][j]['element_name'];
					}
				}
				filter += "</ogc:PropertyName><gml:Polygon srsName='"+srs+"'>";
				filter += "<gml:outerBoundaryIs><gml:LinearRing><gml:coordinates>";
				filter += rectangle[0].x+","+rectangle[0].y;
				filter += " ";
				filter += rectangle[0].x+","+rectangle[1].y;
				filter += " ";
				filter += rectangle[1].x+","+rectangle[1].y;
				filter += " ";
				filter += rectangle[1].x+","+rectangle[0].y;
				filter += " ";
				filter += rectangle[0].x+","+rectangle[0].y;
				filter += "</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs>";
				filter += "</gml:Polygon></Intersects>";
			}

			filter += "</ogc:Filter>";
			url += param;
			mb_get_geom(url, filter, i, wfs_config[js_wfs_conf_id[i]]['featuretype_name'], js_wfs_conf_id[i], db_wfs_conf_id[i]);
		}
	}
	else if(queryGeom.geomType == geomType.point){
		var tmp = queryGeom.get(0);
		var mapPos = makeRealWorld2mapPos("mapframe1",tmp.x, tmp.y);
		var buffer = mb_wfs_tolerance/2;
		var mapPosXAddPix = mapPos[0] + buffer;
		var mapPosYAddPix = mapPos[1] +buffer;
		var mapPosXRemovePix = mapPos[0] - buffer;
		var mapPosYRemovePix = mapPos[1] - buffer;
		var realWorld1 = makeClickPos2RealWorldPos("mapframe1",mapPosXRemovePix,mapPosYRemovePix);
		var realWorld2 = makeClickPos2RealWorldPos("mapframe1",mapPosXAddPix,mapPosYRemovePix);
		var realWorld3 = makeClickPos2RealWorldPos("mapframe1",mapPosXAddPix,mapPosYRemovePix);
		var realWorld4 = makeClickPos2RealWorldPos("mapframe1",mapPosXRemovePix,mapPosYAddPix);
		for(var i=0; i<js_wfs_conf_id.length; i++){
			var srs = wfs_config[js_wfs_conf_id[i]]['featuretype_srs'];
			var url = wfs_config[js_wfs_conf_id[i]]['wfs_getfeature'];
			url += mb_getConjunctionCharacter(wfs_config[js_wfs_conf_id[i]]['wfs_getfeature']);
			param = "service=wfs&request=getFeature&version=1.0.0&typename="+ wfs_config[js_wfs_conf_id[i]]['featuretype_name']+"&filter=";
			var filter = "<ogc:Filter xmlns:ogc='http://ogc.org' xmlns:gml='http://www.opengis.net/gml'>";
			filter += "<Intersects><ogc:PropertyName>";
			for(var j=0; j<wfs_config[js_wfs_conf_id[i]]['element'].length; j++){
				if(wfs_config[js_wfs_conf_id[i]]['element'][j]['f_geom'] == 1){
					filter += wfs_config[js_wfs_conf_id[i]]['element'][j]['element_name'];
				}
			}
			filter += "</ogc:PropertyName><gml:Polygon srsName='"+srs+"'><gml:outerBoundaryIs><gml:LinearRing><gml:coordinates>";
			filter += realWorld1[0] + "," + realWorld1[1] + " " + realWorld2[0] + "," + realWorld2[1] +  " ";
			filter += realWorld3[0] + "," + realWorld3[1] + " " + realWorld4[0] + "," + realWorld4[1] + " " + realWorld1[0] + "," + realWorld1[1];
			filter += "</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs></gml:Polygon></Intersects></ogc:Filter>";
			url += param;
			mb_get_geom(url, filter, i, wfs_config[js_wfs_conf_id[i]]['featuretype_name'], js_wfs_conf_id[i], db_wfs_conf_id[i]);
		}
	}
//	highlight = new Highlight(mb_wfs_targets, highlight_tag_id, {"position":"absolute", "top":"0px", "left":"0px", "z-index":generalHighlightZIndex}, generalHighlightLineWidth);
	return true;
}

function mb_get_geom(url, filter, index, typename, js_wfs_conf_id, db_wfs_conf_id) {

	mb_ajax_post("../" + wfsResultModulePath + wfsResultModuleFilename,{'url':url,'filter':filter,'typename':typename,'js_wfs_conf_id':js_wfs_conf_id, 'db_wfs_conf_id':db_wfs_conf_id},function(js_code,status){
		if (js_code) {
			eval(js_code);
		}
		if (typeof(geom) == "undefined") {
			var geom = new GeometryArray();
		}
		checkIfAllAjaxCallsFinished(geom);
//		prompt('', js_code);
	});
}

function checkIfAllAjaxCallsFinished (geom) {
	numberOfFinishedAjaxCalls++;
	if (typeof(geom) == 'object'){
		_geomArray.union(geom);
	}
	if (numberOfFinishedAjaxCalls == numberOfAjaxCalls) {
		numberOfFinishedAjaxCalls = 0;
		mb_execWfsReadSubFunctions(_geomArray);

	}
}

function useExtentIsSet () {
	return mod_wfs_spatialRequest_useExtent;
}

function isValidWfsConfIndex (wfsConf, wfsConfIndex) {
	return (typeof(wfsConfIndex) == "number" && wfsConfIndex >=0 && wfsConfIndex < wfsConf.length);
}

function Numsort (a, b) {
  return a - b;
}

function getListTitle (geom) {
	wfsConfId = geom.wfs_conf;
	wfsConf = get_complete_wfs_conf();
	if (isValidWfsConfIndex(wfsConf, wfsConfId)) {
		var resultArray = [];
		var resultName = "";
		for (var i = 0 ; i < wfsConf[wfsConfId]['element'].length ; i++) {
			if (wfsConf[wfsConfId]['element'][i]['f_show'] == 1 && geom.e.getElementValueByName(wfsConf[wfsConfId]['element'][i]['element_name']) !=false) {
				var pos = wfsConf[wfsConfId]['element'][i]['f_respos'];
				if (typeof(resultArray[pos]) != "undefined") {
					resultArray[pos] += " " + geom.e.getElementValueByName(wfsConf[wfsConfId]['element'][i]['element_name']);
				}
				else {
					resultArray[pos] = geom.e.getElementValueByName(wfsConf[wfsConfId]['element'][i]['element_name']);
				}
				resultName += geom.e.getElementValueByName(wfsConf[wfsConfId]['element'][i]['element_name']) + " ";
			}
		}
		resultArray.sort(Numsort);
		var resultName = resultArray.join(" ");
		if (resultName == "") {
			resultName = wfsConf[wfsConfId]['g_label'];
		}
		return resultName;
	}
	else {
		return msgObj.digitizeDefaultGeometryName;
	}
}

function appendGeometryArrayToDigitize(geom){
	parent.window.frames[mod_digitize_elName].appendGeometryArray(geom);
        try {
                parent.tab_open(mod_digitize_elName);
        }
        catch(err) {}
}

function appendGeometryToDigitize(i){
	var digitizeArray = new GeometryArray();
	digitizeArray.addCopy(_geomArray.get(i));
	parent.window.frames[mod_digitize_elName].appendGeometryArray(digitizeArray);
	try {
                parent.tab_open(mod_digitize_elName);
        }
        catch(err) {}
}

function createListOfGeometries(){
	var listOfGeom = "<table style='background-color:#EEEEEE;'>\n";
	if (_geomArray.count() > 0) {
		if(buttonWfs_toDigitize_on==1){
			listOfGeom += "<tr><td style='color:black;font-size:12px;'>edit all</td>\n";
			listOfGeom += "<td><img title='edit all' src='"+buttonWfs_toDigitize_src+"'  style='cursor:pointer' onclick='appendGeometryArrayToDigitize(_geomArray);'></img>";
			listOfGeom += "</td>\n</tr>\n";
			listOfGeom += "<tr>\n<td>&nbsp;</td>\n</tr>\n";
		}
		for (var i = 0 ; i < _geomArray.count(); i ++) {
			if (_geomArray.get(i).get(-1).isComplete()) {
				listOfGeom += "\t<tr>\n\t\t<td style = 'color:blue;font-size:12px;cursor:pointer;'\n";
				listOfGeom += "\t\t\t onmouseover='mb_wfs_perform(\"over\",_geomArray.get("+i+"));' ";
				listOfGeom += " onmouseout='mb_wfs_perform(\"out\",_geomArray.get("+i+"))' ";
				listOfGeom += " onclick='mb_wfs_perform(\"click\",_geomArray.get("+i+")); showWfs("+i+");' ";
				var geomName = getListTitle(_geomArray.get(i));
				//if (_geomArray.get(i).geomType == geomType.polygon) {geomName += "(polygon)";}
				//else if (_geomArray.get(i).geomType == geomType.line) {geomName += "(line)";}
				//else if (_geomArray.get(i).geomType == geomType.point) {geomName += "(point)";}
				listOfGeom += ">" + geomName +"</td>";
				if(buttonWfs_toDigitize_on==1){
					listOfGeom += "<td><img title='edit geometry object' src='"+buttonWfs_toDigitize_src+"'  style='cursor:pointer' onclick='appendGeometryToDigitize("+i+");'></img></td>";
				}
				listOfGeom += "\t\t</tr>\n";
			}
		}
	}
	listOfGeom += "</table>\n";
	return listOfGeom;
}

function displayPopup(geom){
	_geomArray = geom;
	if (typeof(resultGeometryPopup) == "undefined") {
		resultGeometryPopup = new mb_popup(searchPopupTitle,createListOfGeometries(),searchPopupWidth,searchPopupHeight,searchPopupX,searchPopupY);
	}
	else {
		resultGeometryPopup.setWidth(searchPopupWidth);
		resultGeometryPopup.setHtml(createListOfGeometries());
	}
	resultGeometryPopup.show();
}

function showWfs(geometryIndex) {
	var wfsConfIndex = _geomArray.get(geometryIndex).wfs_conf;
	var currentWfsConf = wfsConf[wfsConfIndex];

	var resultHtml = "";
	resultHtml += "<table style='background-color:#EEEEEE;'>\n";
	for (var i = 0 ; i <currentWfsConf.element.length; i ++) {
	    if(currentWfsConf.element[i].f_show_detail==1){
	    	if( _geomArray.get(geometryIndex).e.getElementValueByName(currentWfsConf.element[i].element_name)!=false){
				//console.log(currentWfsConf.element[i].element_name+"---"+currentWfsConf.element[i].f_respos);
				resultHtml +="<tr><td>\n";
				resultHtml += currentWfsConf.element[i].f_label;
				resultHtml +="</td>\n";
				resultHtml += "<td>\n";
				var elementVal = _geomArray.get(geometryIndex).e.getElementValueByName(currentWfsConf.element[i].element_name);
				if(currentWfsConf.element[i].f_form_element_html.indexOf("href")!=-1){
					var setUrl = currentWfsConf.element[i].f_form_element_html.replace(/href\s*=\s*['|"]\s*['|"]/, "href='"+elementVal+"' target='_blank'");
					if(setUrl.match(/><\/a>/)){
						var newLink	=	setUrl.replace(/><\/a>/, ">"+elementVal+"</a>");
					}
					else{
						var newLink = setUrl;
					}
					if(openLinkFromSearch=='1'){
						window.open(elementVal, elementVal,"width=500, height=400,left=100,top=100,scrollbars=yes");
					}
					resultHtml +=  newLink;
				}
				else{
					resultHtml += elementVal;
				}
				resultHtml += "</td></tr>\n";
			}
		}
	}
	resultHtml += "</table>\n";

	var getCenter =  _geomArray.get(geometryIndex).getCenter();
	// getMapPos for positioning of new PopupDiv near object in mapframe1
	//var getMapPos = makeRealWorld2mapPos("mapframe1",getCenter.x, getCenter.y);
	if (typeof(wfsPopup) == "undefined") {
		wfsPopup = new mb_popup(detailPopupTitle,resultHtml,detailPopupWidth,detailPopupHeight,detailPopupX,detailPopupY);
	}
	else {
		wfsPopup.hide();
		wfsPopup = new mb_popup(detailPopupTitle,resultHtml,detailPopupWidth,detailPopupHeight,detailPopupX,detailPopupY);
	}
	wfsPopup.show();
}
try{
	if (wfsResultToPopupDiv){}
}
catch(e){
	wfsResultToPopupDiv =0;
}
if(wfsResultToPopupDiv==1){
	mb_registerWfsReadSubFunctions(function(geom){displayPopup(geom);});
}


More information about the Mapbender_dev mailing list