//---------------------------------
// ON LOADING
//---------------------------------
	
	//---------------------------------
	// Definition of Variables
	//---------------------------------
	
		// Layers (DIV) - JS Variables
		var editlyr = 'edit';			// ID of layer for drawing
		var maplyr = 'main_anchor';		// ID of layer including map image
		var bildlyr = 'karte';			// ID of map image tag
		var divlyr = bildlyr + 'div';		// ID of layer für IE wenn drag&drop - NICHT VERÄNDERN !!!
		var processinglyr = 'processing';	// ID of layer for image/text processing -> to be visible when loading
		var keylyr = 'keymap';			// ID of layer for keymap
		var editkeylyr = 'editkeymap';		// ID of layer for keymapdrawing
		var toplyr = 'toplayer';		// I
		
		// HTTP_FORM_VARS -> INPUT and FORM parameters
		var theform = 'map_form';		// Name of FORM-TAG that includes map and all input tags
		var thetool = 'CMD';			// Name of INPUT-TAG (CMD)
		var theminx = 'img_minx';		// Name of INPUT-TAG for act mapextent and box coordinates
		var theminy = 'img_miny';		// Name of INPUT-TAG for act mapextent and box coordinates
		var themaxx = 'img_maxx';		// Name of INPUT-TAG for act mapextent and box coordinates
		var themaxy = 'img_maxy';		// Name of INPUT-TAG for act mapextent and box coordinates
		var themapminx = 'minx';			// Name of INPUT-TAG for act mapextent printed by mapserver
		var themapminy = 'miny';			// Name of INPUT-TAG for act mapextent printed by mapserver
		var themapmaxx = 'maxx';			// Name of INPUT-TAG for act mapextent printed by mapserver
		var themapmaxy = 'maxy';			// Name of INPUT-TAG for act mapextent printed by mapserver
		var theminxext = 'dfminx';		// Name of INPUT-TAG for minx of MapExtent
		var theminyext = 'dfminy';		// Name of INPUT-TAG for miny
		var themaxxext = 'dfmaxx';		// Name of INPUT-TAG for maxx
		var themaxyext = 'dfmaxy';		// Name of INPUT-TAG for maxy
//		var geom_type = 'imagemap_geom_stroke_width';		// Name of geom type
		// JS Variables
		var color = '#9B0000';		// Color for JS drawing
		var stroke = 1;			// Stroke size for JS drawing (px)
		var pointsize = 4;		// Point size for JS drawing (px)
		
//		alert(theform);
//		el2 = doocument.map_form.imagemap_geom_stroke_width;
//		alert(el2);
//		if (el2=='line') {
//			var mouse_over_stroke = 5; //m
//		}	else {
			var mouse_over_stroke = 2; //m
//		}
		var mouse_over_stroke_color = '#800000';
		var mouse_over_fill_color = '#DD0000';
		//-----------------//
		var boxing=0; var keymoving=0;;	// Variables for Boxing and moving
		var circling=0;
		var xPoint,yPoint;		// Variables for Boxing
		var theObj = new Object;
		var loading_map_img_x = 'loading_map_img_x';    // Name of INPUT-TAG for x-Position of map
		var loading_map_img_y = 'loading_map_img_y';    // Name of INPUT-TAG for y-Position of map
		var loading_map = 'loading_map'; // Name of INPUT-TAG for DIV of loading map
		//-----------------//
 		var thescale = 'scale';		// Name des INPUt-tag des Maßstabs (für die Berechnung der gemessenen Distanzen)
		var thedistance = 'distance';	// Name des INPUT-tag für die Ausgabe der gemessenen Distanzen
		var circleRadius = 0;		// Variable für den Radius
		var ruling=0; var ruling_circle=0;
		
		var XArray = new Array();
		var YArray = new Array();
		var xx = new Array();
		var yy = new Array();
		
		var boxrelation=''; // Box für zoom in ratio = 'locked' oder eben nicht ('')
		var thezindex_top=500;
			
			
		////// offset der gezeichneten imagemap polygone
		var im_offset_x=0;
		var im_offset_y=-2;
	//---------------------------------
	//---------------------------------


	//---------------------------------
	// Check Browser
	// Necessary for the capture of screen/pixel coordinates
	//---------------------------------
	var browserNS = (navigator.appName.indexOf("Netscape") >= 0);
	var browserIE = (navigator.appName.indexOf("Microsoft Internet Explorer") >= 0);
	
	//---------------------------------
	//---------------------------------
	

	
//-------------------------------------------------------//
// FUNCTIONS --- FUNCTIONS ---- FUNCTIONS ---- FUNCTIONS //
//-------------------------------------------------------//

	
	//---------------------------------
	// DOM CHECK/ Check for various browser 
	//---------------------------------
	
	
		//---------------------------------
		//---------------------------------
		// DOM check
		function getObj(name)
		{
		  if (document.getElementById)
		  {
		  	doc = document.getElementById(name);
		  }
		  else if (document.all)
		  {
			doc = document.all[name];
		  }
		  else if (document.layers)
		  {
		   	doc = document.layers[name];
		  }
		  
		  return doc
		}
		//---------------------------------
		//---------------------------------	
	
	//---------------------------------
	//---------------------------------
	function myShowHideLegendItem(item) 
			{
						item2= 'layerdiv_' + item;
						el = getObj(item2);

							if (el.style.display) {
								
								if (el.style.display=='none') {
									el.style.display = 'block';
//										myFormOutput(theform,'layerdiv_' + item,'block');
									document.images['leg_arrow_' + item].src = '../img/arrow2_down.gif';
								} else {
									el.style.display = 'none';
//										myFormOutput(theform,'layerdiv_' + item,'none');
									document.images['leg_arrow_' + item].src = '../img/arrow2_left.gif';
								}
								
							} else {
									el.style.display = 'none';
//										myFormOutput(theform,'layerdiv_' + item,'none');
									document.images['leg_arrow_' + item].src = '../img/arrow2_left.gif';
							}
			}
		
		//liste index.php
		function myShowHideLegendItem_predef_domain(item,item_dom,path) 
			{
						item2= 'layerdiv_' + item;
						el = getObj(item2);
						el2 = getObj(item_dom);

							if (el.style.display) {
								
								if (el.style.display=='none') {
									el.style.display = 'block';
//										myFormOutput(theform,'layerdiv_' + item,'block');
									document.images['leg_arrow_' + item].src = path+'lo_map_idx_pfeil_un_gelb.gif';
									el2.style.backgroundColor='#B6B2AB';
									el2.style.color='#FFFF00';
//									el2.style.className='map_index_domain_back_active';
								} else {
									el.style.display = 'none';
//										myFormOutput(theform,'layerdiv_' + item,'none');
									document.images['leg_arrow_' + item].src = path+'lo_map_idx_pfeil_re_grau.gif';
									el2.style.backgroundColor='';
									el2.style.color='';
								}
								
							} else {
									el.style.display = 'none';
//										myFormOutput(theform,'layerdiv_' + item,'none');
									document.images['leg_arrow_' + item].src = path+'lo_map_idx_pfeil_un_gelb.gif';
									el2.style.backgroundColor='';
									el2.style.color='';
							}
			}
			function myShowHideLegendItem_predef_grp(item,item_dom,item_map,path) 
			{
						item2= 'layerdiv_' + item;
						el = getObj(item2);
						el2 = getObj(item_dom);
						el3 = getObj(item_map);

							if (el.style.display) {
								
								if (el.style.display=='none') {
									el.style.display = 'block';
//										myFormOutput(theform,'layerdiv_' + item,'block');
									document.images['leg_arrow_' + item].src = path+'lo_map_idx_pfeil_un_grau.gif';
									el2.style.fontWeight ='bold';
									el3.style.fontWeight ='bold';
//									el2.style.className='map_index_domain_back_active';
								} else {
									el.style.display = 'none';
//										myFormOutput(theform,'layerdiv_' + item,'none');
									document.images['leg_arrow_' + item].src = path+'lo_map_idx_pfeil_re_grau.gif';
									el2.style.fontWeight='';
									el3.style.fontWeight='';
								}
								
							} else {
									el.style.display = 'none';
//										myFormOutput(theform,'layerdiv_' + item,'none');
									document.images['leg_arrow_' + item].src = path+'lo_map_idx_pfeil_un_grau.gif';
									el2.style.fontWeight='';
									el3.style.fontWeight='';
							}
			}
		
		
		
			// für die liste, popup aus map.php
		function myShowHideLegendItem_predef_map(item) 
			{
						item2= 'layerdiv_' + item;
						el = getObj(item2);

							if (el.style.display) {
								
								if (el.style.display=='none') {
									el.style.display = 'block';
//										myFormOutput(theform,'layerdiv_' + item,'block');
									document.images['leg_arrow_' + item].src = '../img/nolines_minus2.gif';
								} else {
									el.style.display = 'none';
//										myFormOutput(theform,'layerdiv_' + item,'none');
									document.images['leg_arrow_' + item].src = '../img/nolines_plus2.gif';
								}
								
							} else {
									el.style.display = 'none';
//										myFormOutput(theform,'layerdiv_' + item,'none');
									document.images['leg_arrow_' + item].src = '../img/nolines_minus2.gif';
							}
			}

//--------------------------------------------------------
// Create layers necessary
//--------------------------------------------------------	
	
//	//--------------------------------------------------------
//	// Create Layer Function - GENERAL
//	function createLayer(id, left, top, width, height, content, visible) {
//		document.write('<div id="' + id + '"  style="overflow:hidden; margin-left: 0; margin-top: 0; margin-bottom: 0; margin-right: 0; position: absolute; left: ' + left + '; top: ' + top + '; width: ' + width + '; height: ' + height + '; visibility: ' + visible + '; z-index:500;" >' + content + '</div>');
//	}
	//--------------------------------------------------------
	// Create Layer Function - GENERAL
	function createLayer(id, left, top, width, height, content, visible, display) {
		document.write('<div id="' + id + '" style="overflow:hidden; margin-left: 0; margin-top: 0; margin-bottom: 0; margin-right: 0; position: absolute; left:' + left + 'px; top:' + top + 'px; width:' + width + 'px; height:' + height + 'px; visibility:' + visible + '; display:' + display + '; z-index:' + thezindex_top + ';">' + content + '</div>');
	}
	function createKeyLayer(id, left, top, width, height, content, visible, display) {
		document.write('<div id="' + id + '" onmousemove="document.onmousedown=null;" onmouseover="document.onmousedown=null;" onmouseout="document.onmousedown=PICK;" style="overflow:hidden; margin-left: 0; margin-top: 0; margin-bottom: 0; margin-right: 0; position: absolute; left:' + left + 'px; top:' + top + 'px; width:' + width + 'px; height:' + height + 'px; visibility:' + visible + '; display:' + display + '; z-index:' + thezindex_top + ';">' + content + '</div>');
	}
	//--------------------------------------------------------
	//--------------------------------------------------------
	
	
	//--------------------------------------------------------
	//--------------------------------------------------------
	
	//--------------------------------------------------------
	// Create Edit Layer Function
	function createEditLayer(id, toplayer, width, height, visible) {
		x = getPageXY(toplayer);
		content = "";
		createLayer(id, x[0], x[1], width, height, content, visible);					
	}
	//--------------------------------------------------------
	//--------------------------------------------------------
	
	//--------------------------------------------------------
	// Create Processing Layer Function
	function createProcessingLayer(id, toplayer, width, height, w, h, content, visible) {
	
		// FIND POSITION of PROCESSING LAYER
		x = getPageXY(toplayer);
		w = w / 2;
		h = h / 2;
		prox = x[0] + w;
		proy = x[1] + h;
		prow = width / 2;
		proh = height / 2;
		prox = prox - prow;
		proy = proy - proh;
 				
		createLayer(id, prox, proy, width, height, content, visible);					
	}
	
		// Processing state - Processing layer
		//---------------------------------
			// Processing state START
			//---------------------------------
			function startProcessingState() {
				el=getObj(processinglyr);
				el.style.visibility = 'visible';
				document.body.style.cursor = 'wait';
			}
			// Processing state STOP
			//---------------------------------
			function stopProcessingState() {
				el=getObj(processinglyr);
				el.style.visibility = 'hidden';
				document.body.style.cursor = 'default';
			}
			//---------------------------------	
		//---------------------------------	
		
	//--------------------------------------------------------
	//--------------------------------------------------------


	//--------------------------------------------------------
	// Find position of layer (DIV)
	//--------------------------------------------------------
	  function getPageXY(name)                                  
	{                                                         
		el = getObj(name);		// get object     
		if (el.pageX)                                     
		{                                                 
			x = el.pageX || 0;                        
			y = el.pageY || 0;                        
		}                                                 
		else                                              
		{                                                 
			 x=0; y=0;                                
			while (el)                                
			{                                         
				x += el.offsetLeft;               
				y += el.offsetTop;                
				el = el.offsetParent || null;     
			}                                         
		}                                                 
		return [x,y]                                      
	};   
	  //--------------------------------------------------------


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




	
//--------------------------------------------------------
// USER INPUT - BUTTONS; KEYS; -> triggering functions
//--------------------------------------------------------

	
	//---------------------------------
	// User Input - Buttons --> TOOLS THAT CAN BE CHOSEN
	//---------------------------------
	function doButton(tool,button)
	{
	    el = document.forms[theform].elements;
	    var oldtool = el[thetool].value;	// FÜr ZOOM_OUT
	    el[thetool].value = tool;
	    
	    ADD_DHTML(bildlyr+NO_DRAG);		// Verhindern, dass drag&drop möglich ist, obwohl inzwischen ein anderes tool gewählt worden ist.
	    
		if (divlyr) { ldiv=getObj(divlyr); } else { ldiv=getObj(maplyr); }	// für IE
		ledit=getObj(editlyr);   //ledit=getObj(editlyr);
		ledit.style.zIndex = 500;
		ltopt=getObj(toplyr);   //ledit=getObj(editlyr);
		ltopt.style.zIndex = 500;
//		document.getElementById('kartedivNImG').useMap = '';



		switch (tool) {
			case "QUERY_CIRCLE":
				ldiv.style.cursor='help';
				ltopt.style.cursor='help';	
//				document.getElementById('distance_div').style.display = 'none';
				captureEvt();
				break;
			case "IMAGE_MAP":
            document.getElementById('kartedivNImG').useMap = '#image_map';
            ledit.style.zIndex = -1;
            ltopt.style.zIndex = -1;
            break;
			case "ZOOM_IN":
				ldiv.style.cursor='crosshair';
				ltopt.style.cursor='crosshair';
//				document.getElementById('distance_div').style.display = 'none';
				captureEvt();
				break;
			case "QUERY_POINT":
				ldiv.style.cursor='help';
				ltopt.style.cursor='help';
//				document.getElementById('distance_div').style.display = 'none';
				captureEvt();
				break;
			case "ZOOM_OUT":
				if (oldtool==tool && button!=1) {
					captureEvt();
				} else {
					ZoomoutButton(maplyr);
				}
				break;
			case "RECENTER":
				ldiv.style.cursor='move';
				ltopt.style.cursor='move';
				captureEvt();
				break;
			case "PAN":
				ldiv.style.cursor='move';	// 'hand' für IE
				ltopt.style.cursor='move';	
				ADD_DHTML(bildlyr+TRANSPARENT+CURSOR_HAND);
				break;
			case "FULL_EXTENT":
				document.forms[theform].submit();
				break;
			case "CANCEL":
				document.forms[theform].submit();
				break;
			case "FORWARD":
				history.forward();
				break;
			case "BACK":
				history.back();
				break;
			case "RULER":
				resetToolGraphics();
				captureEvt();
				document.getElementById('distance_div').style.display='block';
			break;
			case "RULER_CIRCLE":
//				resetToolGraphics();	
	    			captureEvt();
				document.getElementById('distance_div').style.display='block';
			break;
		}		
	}  
	//---------------------------------
	//---------------------------------

function resetToolGraphics() {
		js_graphics.clear();
		XArray = new Array();		// empty X array for drawing
		YArray = new Array();		// empty Y array for drawing
		xx = new Array();		// empty X array for drawing
		yy = new Array();		// empty Y array for drawing
		
	}
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------




//--------------------------------------------------------
// MOUSE EVENTS --> triggering functions for Digitising, Pan, etc.
//--------------------------------------------------------

	//---------------------------------
	// MAP - Mouse Events captured
	//---------------------------------
	
	function captureEvt() {

		if(window.addEventListener) {
			// For Mozilla & co
			ledit=getObj(toplyr);			// für INTERNET EXPLORER
			ledit.addEventListener('mousedown',mouseDownAction,false);
			ledit.addEventListener('mouseup',mouseUpAction,false);
			ledit.addEventListener('mousemove',mouseMoveAction,false);
			ledit.addEventListener('dblclick',mouseStopAction,false);
		} else {	
			// For IE    
		  	if (bildlyr) {
				ldiv=getObj(divlyr);			// für INTERNET EXPLORER
			  	ldiv.onmousedown = mouseDownAction;
				ldiv.onmouseup = mouseUpAction;
				ldiv.onmousemove = mouseMoveAction;
				ldiv.ondblclick = mouseStopAction;
			   } else {
		 		lmap=getObj(maplyr);			// for INTERNET EXPLORER (Opera?) if no drag&drop of map (ldiv)
				lmap.onmousedown = mouseDownAction;
				lmap.onmouseup = mouseUpAction;
				lmap.onmousemove = mouseMoveAction;
				lmap.ondblclick = mouseStopAction;
			   }
		}

		// For Opera 
		ledit=getObj(toplyr);			
		ledit.onmousedown = mouseDownAction;
		ledit.onmouseup = mouseUpAction;
		ledit.onmousemove = mouseMoveAction;
		ledit.ondblclick = mouseStopAction;

	}
	//---------------------------------
	//---------------------------------
		//---------------------------------
	// IMAGE_MAP QUERY
	function captureIMGEvt() {
				
		// For Opera 
		ldown=getObj('kartediv');			
		ldown.onmousedown = mouseDownAction;
		
		// IE
		ldiv=getObj(divlyr);			
		ldiv.onmousemove = mouseMoveAction;
		ldiv.onmouseup = mouseUpAction;
		// FIREFOX
		ledit=getObj(toplyr);			
		ledit.onmousemove = mouseMoveAction;
		ledit.onmouseup = mouseUpAction;

	}
	
	function captureIMGMAPEvt(evt) {
		if (!evt) { evt = window.event; }
		if (evt.target) {
			var elem = evt.target;
		} else { var elem = evt.srcElement; }
		elem.onmousedown = mouseDownAction;
		captureIMGEvt();
		return true;
	}
	//---------------------------------

	//---------------------------------
	// KEYMAP - Mouse Events captured
	//---------------------------------
	function captureKeymapEvt() {
		
		// For IE
		lkey=getObj(keylyr);		
		lkey.onmousedown = mouseKeymapDownAction; 	// for INTERNET EXPLORER
		lkey.onmouseup = mouseKeymapUpAction; 		// for INTERNET EXPLORER
		lkey.onmousemove = mouseKeymapMoveAction; 	// for INTERNET EXPLORER
		// For everything else
		elkey=getObj(editkeylyr);		
		elkey.onmousedown = mouseKeymapDownAction; 	// Layer mouse actions
		elkey.onmouseup = mouseKeymapUpAction; 		// Layer mouse actions
		elkey.onmousemove = mouseKeymapMoveAction; 	// Layer mouse actions
	}
	//---------------------------------
	
	
	
	
	//---------------------------------
	// !!MAP!! - MOUSE EVENT HANDLERS -----------
	//---------------------------------
	
		// on Mouse Down
		//---------------------------------
		function mouseDownAction(evt) {
//			if (!evt) {
//    				var evt = window.event;
//  		  		evt.cancelBubble = true;
// 			 }
// 			if (evt.stopPropagation) {
// 			   evt.stopPropagation();
//			}
			el = document.forms[theform].elements;
	    		tool = el[thetool].value;
			switch (tool) {
				case "ZOOM_IN":
					height = getHeight(editlyr);	
					width = getWidth(editlyr);	
					if (boxrelation=='locked') {
						boxRelation = height/width;
					} else {
						boxRelation = '';
					}
					startBox(evt,maplyr,boxRelation);
					boxing=1;
					break;
				case "QUERY_POINT":
					boxRelation = '';
					startBox(evt,maplyr,boxRelation);
					boxing=1;
					break;
				case "ZOOM_OUT":
					Zoomout(evt,maplyr); 
					break;
				case "RECENTER":
					Recenter(evt,maplyr);
					break;
				case "QUERY_CIRCLE":
					startCircle(evt,maplyr);
					circling=1;
					break;
				case "RULER":
					drawMouseLine(evt,maplyr);
					calculateLines(XArray,YArray);
					ruling = 1;
			break;	
			case "RULER_CIRCLE":
				startCircle(evt,maplyr);
				calculateDistance(circleRadius);
				ruling_circle = 1;
			break;	
			case "IMAGE_MAP":
							document.getElementById(divlyr + 'NImG').useMap = '';
							ledit=getObj(editlyr);		// F�r alle anderen Browser (zumindest Firefox)
				 	    ltop=getObj(toplyr);
							ltop.style.zIndex = thezindex_top;
							ledit.style.zIndex = thezindex_top;
							boxRelation = '';
							boxing=1;
							startBox(evt,maplyr,boxRelation);
					break;
			}
			return false;				
		}
		//---------------------------------
		
		// on Mouse Moving
		//---------------------------------
		function mouseMoveAction(evt) {
//			if (!evt) {
//    				var evt = window.event;
//  		  		evt.cancelBubble = true;
// 			 }
// 			if (evt.stopPropagation) {
// 			   evt.stopPropagation();
//			}
			if (boxing==1) { drawBox(evt,maplyr); }
			if (circling==1) { drawCircle(evt,maplyr); }
			if (ruling==1) { drawMouseLastLine(evt,maplyr); calculateLines(XArray,YArray); }
			if (ruling_circle==1) { drawCircle(evt,maplyr); calculateDistance(circleRadius); }
		
		}
		//---------------------------------
		
		// on Mouse Up
		//---------------------------------
		function mouseUpAction(evt) {
//			if (!evt) {
//    				var evt = window.event;
//  		  		evt.cancelBubble = true;
// 			 }
// 			if (evt.stopPropagation) {
// 			   evt.stopPropagation();
//			}
			if (boxing==1) {
				tool = myFormInput(theform,thetool);
						if (tool=='IMAGE_MAP') {
							myFormOutput(theform,thetool,'QUERY_POINT'); 
						}
				stopBox(evt,maplyr);
				boxing=0;
			}
			if (circling==1) {
				stopCircle(evt,maplyr);
				circling=0;
			}
			if (ruling_circle==1) { 	
				ruling_circle=0; 
			}
		}
		//---------------------------------
		function mouseStopAction(evt) {
			//-----------
//			if (!evt) {
//    				var evt = window.event;
//  				evt.cancelBubble = true;
// 			}
// 			if (evt.stopPropagation) {
// 			   evt.stopPropagation();
//			}
			if (ruling==1) { 
				stopRulerAction();
			}
		}

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



	//---------------------------------
	// !!KEYMAP!! - MOUSE EVENT HANDLERS -----------
	//---------------------------------

		// on Mouse Down
		//---------------------------------
		function mouseKeymapDownAction(evt) {
			keymoving=1;
			startKeyMove(evt,editkeylyr);
		}
		//---------------------------------
		
		// on Mouse Moving
		//---------------------------------
		function mouseKeymapMoveAction(evt) {
			if (keymoving==1) { 
				drawKeyMove(evt,editkeylyr);
			}	
		}
		//---------------------------------
		
		// on Mouse Up
		//---------------------------------
		function mouseKeymapUpAction(evt) {
			stopKeyMove(evt,editkeylyr);
			keymoving=0;
		}
		//---------------------------------
	
	//---------------------------------
	//---------------------------------


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



//--------------------------------------------------------
// MOUSE POSITION - CALCULATE X and Y within layer (not of whole site)
//--------------------------------------------------------
	
	//---------------------------------
	//---------------------------------
	// Get x location of mouse on layer
	//---------------------------------
	function getImageX(evt,lyr) {
		if (browserNS) {
			mouseX = evt.pageX;	// Screen coordinates
		} else {
			mouseX = event.clientX + document.body.scrollLeft;	// Screen coordinates
		}

		xy=getPageXY(lyr);	// find position of layer
		mouseX = mouseX-xy[0];	// calculate position within layer (screen coordinates - layer coordinates)
		return mouseX;
	}
	
	// Get y location of mouse on layer
	//---------------------------------
	function getImageY(evt,lyr) {
		if (browserNS) {
			mouseY = evt.pageY;	// Screen coordinates
		} else {
			mouseY = event.clientY + document.body.scrollTop;	// Screen coordinates
		}
		
		xy=getPageXY(lyr);	// find position of layer                                                  			
		mouseY = mouseY-xy[1];  // calculate position within layer (screen coordinates - layer coordinates)              
		return mouseY;
	}
	//---------------------------------
	//---------------------------------

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



//--------------------------------------------------------
// DRAWING WITH JAVASCRIPT - with Walter Zorn javascript library
// EDITING LAYER "editlyr" calles js_graphics
//--------------------------------------------------------


	//---------------------------------
	// Draw Box
	//---------------------------------
	function startBox(evt,lyr,boxRelation) {
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			boxStartX = imageX;
			boxStartY = imageY;
			boxWidth = 0;
			boxHeight = 0;
			
		}
	
	function drawBox(evt,lyr) {
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			height = getHeight(lyr);	
			width = getWidth(lyr);	
			js_graphics.clear(); // damit jeweils nur ein rahmen sichtbar
			
				// if box is going upwards + box is going backwards
				if (boxStartY>imageY && boxStartX>imageX)
				{
					boxWidth = boxStartX - imageX;
					xTest = boxStartX - boxWidth;
				
					if (xTest>0) { xPoint = xTest; } 
						else { 
							xPoint = 0;
							boxWidth = boxStartX - xPoint; 
						}
					if (boxRelation) { boxHeight = boxWidth * boxRelation; } 
					else { boxHeight = boxStartY - imageY; }
					
					yTest = boxStartY - boxHeight;
							
					if (yTest>0) { yPoint = yTest; } 
						else { 
							yPoint = 0; 
							boxHeight = boxStartY - 0; 
							if (boxRelation) { boxWidth = boxHeight / boxRelation; } 
							else { boxWidth = boxStartX - imageX; }
							xPoint = boxStartX - boxWidth; 
						}
				}
//				if ((boxStartY>imageY && boxStartX==imageX) || (boxStartY<imageY && boxStartX==imageX) || (boxStartY==imageY && boxStartX<imageX) || (boxStartY==imageY && boxStartX>imageX))
//				{
//					xPoint = boxStartX;
//					yPoint = boxStartY;
//					boxWidth = 0;
//					boxHeight = 0;
//				}
				// if box is going downwards + box is going backwards
				if (boxStartY<imageY && boxStartX>imageX) {
					boxWidth = boxStartX - imageX;
					xTest = boxStartX - boxWidth;
					
					if (xTest>0) { xPoint = xTest; } 
						else { xPoint = 0; boxWidth = boxStartX - xPoint; }
					
					yPoint = boxStartY;
					
					if (boxRelation) { boxHeight = boxWidth * boxRelation; } 
						else { boxHeight = imageY - boxStartY; }
					
					yTest = yPoint + boxHeight;
					if (yTest<height) { } 
						else { yTest = height; boxHeight = yTest - boxStartY; 
							if (boxRelation) { boxWidth = boxHeight / boxRelation; } 
							else { boxWidth = boxStartX - imageX; }
							xPoint = boxStartX - boxWidth; 
						}  
				}
				// if box is going upwards + box is going forwards
				if (boxStartY>imageY && boxStartX<imageX) {
					xPoint = boxStartX;
					boxWidth = imageX - boxStartX;
					
					xTest = boxStartX + boxWidth;
					if (xTest<width) { } 
						else { xTest = width; boxWidth = xTest - boxStartX; }
					
					if (boxRelation) { boxHeight = boxWidth * boxRelation; } 
						else { boxHeight = boxStartY - imageY; }
					
					yTest = boxStartY - boxHeight;
					if (yTest>0) { yPoint = yTest; } 
						else { 
							yPoint = 0; 
							boxHeight = boxStartY - 0; 
							if (boxRelation) { boxWidth = boxHeight / boxRelation; } 
							else { boxWidth = imageX - boxStartX; }
						}
				}
				// if box is going downwards + box is going forwards
				if (boxStartY<imageY && boxStartX<imageX) {
					xPoint = boxStartX;
					boxWidth = imageX - boxStartX;
					
					xTest = boxStartX + boxWidth;
					if (xTest<width) { } 
						else { xTest = width; boxWidth = xTest - boxStartX; }
					
					yPoint = boxStartY;
					if (boxRelation) { boxHeight = boxWidth * boxRelation; } 
						else { boxHeight = imageY - boxStartY; }
					yTest = yPoint + boxHeight;
					if (yTest<height)  { } 
						else { 
							yTest = height; 
							boxHeight = yTest - boxStartY; 
							if (boxRelation) { boxWidth = boxHeight / boxRelation; } 
							else { boxWidth = imageX - boxStartX; }
						}  
				}
	
//				window.status = xPoint+' '+yPoint+' '+boxWidth+' '+boxHeight;
	
				js_graphics.setColor(color);
				js_graphics.setStroke(stroke);
				js_graphics.drawRect(xPoint, yPoint, boxWidth, boxHeight);
				js_graphics.paint();
	}
	
	function stopBox(evt,lyr) {
		// if only point
		imageX = getImageX(evt,lyr);
		imageY = getImageY(evt,lyr);
		el = document.forms[theform].elements;

		if ((boxStartY == imageY) && (boxStartX == imageX)) {
			el[theminx].value = boxStartX;
			el[theminy].value = boxStartY;
			el[themaxx].value = boxStartX;
			el[themaxy].value = boxStartY;
			
		}
		// if box
		else {
			// For Mapscript Zoomin-by-rectangle
				yMax = yPoint + boxHeight;
				xMax = xPoint + boxWidth;
				el[theminx].value = xPoint;
				el[theminy].value = yPoint;
				el[themaxx].value = xMax;
				el[themaxy].value = yMax;
			
		}
		document.forms[theform].submit();
	}
	//---------------------------------
	//---------------------------------



	//---------------------------------
	// Recenter - Get pix-coordinates -> give it to mapscript
	//---------------------------------
		function Recenter(evt,lyr) {
	
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			// For Mapscript RECENTER
			el = document.forms[theform].elements;
			el[theminx].value = imageX;
			el[theminy].value = imageY;
			el[themaxx].value = imageX;
			el[themaxy].value = imageY;
			document.forms[theform].submit();
		}
	//---------------------------------
	
	
	//---------------------------------
	// Zoomout - Get pix-coordinates over click in map -> give it to mapscript
	//---------------------------------
		function Zoomout(evt,lyr) {
			
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			// For Mapscript RECENTER
			el = document.forms[theform].elements;
			el[theminx].value = imageX;
			el[theminy].value = imageY;
			el[themaxx].value = imageX;
			el[themaxy].value = imageY;
			document.forms[theform].submit();			
		}
	//---------------------------------
	
	//---------------------------------
	// Zoomout - button and automatic refresh
	//---------------------------------
		
		function ZoomoutButton(lyr) {
			el = document.forms[theform].elements;
			var height=getHeight(maplyr);	
			var width=getWidth(maplyr);
			var geoMinX=getGeoMinX();
			var geoMaxX=getGeoMaxX();
			var geoMinY=getGeoMinY();
			var geoMaxY=getGeoMaxY();
			
			var imageMinX = myGeo2Pix(el[themapminx].value,0, width, geoMinX, geoMaxX);
			var imageMinY = myGeo2Pix(el[themapminy].value,0, height, geoMaxY, geoMinY);
			var imageMaxX = myGeo2Pix(el[themapmaxx].value,0, width, geoMinX, geoMaxX);
			var imageMaxY = myGeo2Pix(el[themapmaxy].value,0, height, geoMaxY, geoMinY);
	
			if (imageMinX!=imageMaxX && imageMinY!=imageMaxY) {
				var imageX = imageMinX + ( (imageMaxX - imageMinX) / 2 );
				var imageY = imageMinY + ( (imageMaxY - imageMinY) / 2 );
			} else {
				var imageX = imageMinX;
				var imageY = imageMinY;
			}
			
			el[theminx].value = imageX;
			el[theminy].value = imageY;
			el[themaxx].value = imageX;
			el[themaxy].value = imageY;
			document.forms[theform].submit();

		}

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

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



//--------------------------------------------------------
// DRAWING WITH JAVASCRIPT - with Walter Zorn javascript library
// KEYMAP LAYER "editkeylyr" calles js_keymap
//--------------------------------------------------------

	//---------------------------------
	// Draw EXTENT in KEYMAP --> calles from body (onload)
	//---------------------------------
	function drawKeyBox(lyr) {
		
		geoMinX=getGeoMinX();	// Actual extent of map
		geoMaxX=getGeoMaxX();
		geoMinY=getGeoMinY();
		geoMaxY=getGeoMaxY();
		geoExtMinX=getGeoExtMinX();	// Maximum extent of map
		geoExtMinY=getGeoExtMinY();
		geoExtMaxX=getGeoExtMaxX();
		geoExtMaxY=getGeoExtMaxY();

		height=getHeight(lyr);	
		width=getWidth(lyr);
	
		// Calculating box extent in keymap
		x1 = myGeo2Pix(geoMinX, 0, width, geoExtMinX, geoExtMaxX);
		x4 = x1;
		x2 = myGeo2Pix(geoMaxX, 0, width, geoExtMinX, geoExtMaxX);
		x3 = x2;
		y1 = myGeo2Pix(geoMinY, 0, height, geoExtMaxY, geoExtMinY);
		y2 = y1;
		y3 = myGeo2Pix(geoMaxY, 0, height, geoExtMaxY, geoExtMinY);
		y4 = y3;
		js_keymap.XArray = Array(x1,x2,x3,x4);
		js_keymap.YArray = Array(y1,y2,y3,y4);
	
		js_keymap.clear();
		js_keymap.setStroke(stroke);
		js_keymap.setColor(color);
		js_keymap.drawPolygon(js_keymap.XArray,js_keymap.YArray);
		js_keymap.paint();
		
	}
	//---------------------------------
	//---------------------------------
	
	
	//---------------------------------
	// Moving and drawing EXTENT in KEYMAP --> change extent of map
	//---------------------------------
	
		// START Moving
		//---------------------------------
		function startKeyMove(evt,lyr) {
			moveStartX = getImageX(evt,lyr);	// start coordinates of mouse down
			moveStartY = getImageY(evt,lyr);
			height = getHeight(lyr);	
			width = getWidth(lyr);
			ShiftXArray = new Array();
			ShiftYArray = new Array();
			ShiftXArray = js_keymap.XArray;
			ShiftYArray = js_keymap.YArray;
		}
		//---------------------------------
		
		// DRAW Moving
		//---------------------------------
		function drawKeyMove(evt,lyr) {
			
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			
			var error=0;
			
		                   // Wenn Maus ausserhalb des Layers, dann keine Zeichnung
		                if (imageX>0 && imageY>0 && imageX<width && imageY<height) 
		                {
		                 // Wenn Maus ausserhalb des Layers, dann keine Zeichnung
				var xPoint = moveStartX - imageX;
				var yPoint = moveStartY - imageY;
		
		                 // Test, ob das Polygon ausserhalb des Layers kommt
		                 for (var i=0; i < js_keymap.XArray.length; ++i)
				{
					var x = js_keymap.XArray[i] - xPoint;
					var y = js_keymap.YArray[i] - yPoint;
		                 	if (y<0 || y>height || x<0 || x>width) { error=1; }
				}
		                // Wenn Polygon innerhalb des Layers, dann zeichnen
		                   
		                   if (error==0) {
		                    	ShiftXArray = new Array();
					ShiftYArray = new Array();
		                   	for (var i=0; i < js_keymap.XArray.length; ++i)
					{
						ShiftXArray[ShiftXArray.length] = js_keymap.XArray[i] - xPoint; 
						ShiftYArray[ShiftYArray.length] = js_keymap.YArray[i] - yPoint;
					}
		                    } else {  ShiftXArray; ShiftYArray; }
 		                 }
        
		        // Drawing
		        js_keymap.clear();
			js_keymap.setStroke(stroke);
			js_keymap.setColor(color);
			js_keymap.drawPolygon(ShiftXArray,ShiftYArray);
			js_keymap.paint();

		}
		//---------------------------------
		
		// STOP Moving
		//---------------------------------
		function stopKeyMove(evt,lyr) {
			
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			
			// if only click but no move
			if ((moveStartX==imageX) && (moveStartY==imageY))
			{
				minx=moveStartX;
				maxx=moveStartX;
				miny=moveStartY;
				maxy=moveStartY;
			} 
			else 
			{
				minx=ShiftXArray[0];
				if (minx<1) minx='0.0';		// Mapserver (zoomrectangle) verträgt kein 0, nur 0.0 für minx
				maxx=ShiftXArray[2];
				miny=ShiftYArray[0];
				maxy=ShiftYArray[2];
			}
			
			el = document.forms[theform].elements;
			el[theminx].value = minx;
			el[theminy].value = miny;
			el[themaxx].value = maxx;
			el[themaxy].value = maxy;
			el[thetool].value = 'KEYPAN';
			
			document.forms[theform].submit();	// Submit new ZOOMBOX (new extent) for map
		}
		//---------------------------------


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


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

	
	//---------------------------------
	// Get current min and max of extent in geocoordinates
		//---------------------------------
		// Get the current minX in geocoordinates
		function getGeoMinX() {
    			el = document.forms[theform].elements;
			return el[themapminx].value;
		}
		//---------------------------------
		// Get the current minY in geocoordinates
		function getGeoMinY() {
    			el = document.forms[theform].elements;
			return el[themapminy].value;
		}
		//---------------------------------
		// Get the current maxX in geocoordinates
		function getGeoMaxX() {
    			el = document.forms[theform].elements;
			return el[themapmaxx].value;
		}
		//---------------------------------
		// Get the current maxY in geocoordinates
		function getGeoMaxY() {
    			el = document.forms[theform].elements;
			return el[themapmaxy].value;
		}
		//---------------------------------
	//---------------------------------
	
	//---------------------------------
	// Get min and max of extent in geocoordinates
		//---------------------------------
		// Get the current minX in geocoordinates
		function getGeoExtMinX() {
    			el = document.forms[theform].elements;
			return el[theminxext].value;
		}
		//---------------------------------
		// Get the current minY in geocoordinates
		function getGeoExtMinY() {
    			el = document.forms[theform].elements;
			return el[theminyext].value;
		}
		//---------------------------------
		// Get the current maxX in geocoordinates
		function getGeoExtMaxX() {
    			el = document.forms[theform].elements;
			return el[themaxxext].value;
		}
		//---------------------------------
		// Get the current maxY in geocoordinates
		function getGeoExtMaxY() {
    			el = document.forms[theform].elements;
			return el[themaxyext].value;
		}
		//---------------------------------
	//---------------------------------
	
	
	//---------------------------------
	// Get image/layer width
	//---------------------------------
	function getWidth(lyr) {
		llyr=getObj(lyr);
		widthpx=llyr.style.width;	//Weite des Layers herausfinden
		width0=widthpx.split("px");					//Splitten der Variable, um nur Pixelanzahl zu bekommen (nicht "450px")
		width=width0[0];
		return width;
	}
	//--------------------------------------------------------
	// Get image/layer height
	//---------------------------------
	function getHeight(lyr) {
		llyr=getObj(lyr);
		heightpx=llyr.style.height;	//Höhe des Layers herausfinden
		height0=heightpx.split("px");
		height=height0[0];
		return height;
	}
	//--------------------------------------------------------
	//--------------------------------------------------------
	



//--------------------------------------------------------
	//--------------------------------------------------------
	function myGeo2Pix(nGeoPos, dfPixMin, dfPixMax, dfGeoMin, dfGeoMax) 
	{
	    dfGeoMin=parseFloat(dfGeoMin);
	    dfGeoMax=parseFloat(dfGeoMax);
	    dfWidthGeo = dfGeoMax - dfGeoMin;
	    dfWidthPix = dfPixMax - dfPixMin;   
	    dfGeoToPix = dfWidthPix / dfWidthGeo;
	    dfDeltaGeo = nGeoPos - dfGeoMin;
	    dfPosPix = dfDeltaGeo * dfGeoToPix;
	    dfPosPix = parseInt(dfPosPix);
	    return dfPosPix;
	}
	
	//--------------------------------------------------------
	//--------------------------------------------------------
	
	function myPix2Geo(nPixPos, dfPixMin, dfPixMax, dfGeoMin, dfGeoMax, nInversePix) 
	{
	    dfGeoMin=parseFloat(dfGeoMin);
	    dfGeoMax=parseFloat(dfGeoMax);
	    dfWidthGeo = dfGeoMax - dfGeoMin;
	    dfWidthPix = dfPixMax - dfPixMin;
	    dfPixToGeo = dfWidthGeo / dfWidthPix;
	
	    if (nInversePix == 0)
	        dfDeltaPix = nPixPos - dfPixMin;
	    else
	        dfDeltaPix = dfPixMax - nPixPos;
	
	    dfDeltaGeo = dfDeltaPix * dfPixToGeo;
	    dfPosGeo = dfGeoMin + dfDeltaGeo;
	   
	    return dfPosGeo;
	}
	//--------------------------------------------------------
	//--------------------------------------------------------


function getImagemapArray(id) {

			varid = document.getElementsByName(id);	
			
			var maxboundminx=0;
			var maxboundminy=0;
			var maxboundmaxx=5000;
			var maxboundmaxy=5000;
			xges = new Array();
			yges = new Array();
			outlinesx = new Array();	
			outlinesy = new Array();	
			var zwpgx, zwpgy;
			zwlastcoordinatex = new Array();
			zwlastcoordinatey = new Array();

			for (var s=0 ; s<varid.length; s++ ) {			
						
							var actcoords = varid[s].coords;
							var actshape = varid[s].shape;					

							invar = actcoords.split(",");
				
				         Xcoords = polyXcoords(invar);
				         Ycoords = polyYcoords(invar);
				         pgx = Xcoords.split(',');
				         pgy = Ycoords.split(',');
				        				         
				         for (var i=0 ; i<pgx.length ; i++ ) {
				         			
				         			pgx[i] = parseInt(pgx[i]);
								      pgy[i] = parseInt(pgy[i]);
				              
				         			if (i==0) {
				         				 var boundminx=pgx[i];
								         var boundmaxx=pgx[i];
								         var boundminy=pgy[i];
								         var boundmaxy=pgy[i];
				         			}
				             
				              if (pgx[i] < boundminx) { boundminx=pgx[i]; }	// get minboundingbox
				              if (pgx[i] > boundmaxx) { boundmaxx=pgx[i]; }	// get maxboundingbox
				              if (pgy[i] < boundminy) { boundminy=pgy[i]; }	// get minboundingbox
				              if (pgy[i] > boundmaxy) { boundmaxy=pgy[i]; }	// get maxboundingbox
		            }
		            	pgx.push(pgx[0]);
				         	pgy.push(pgy[0]);

		         
							if (s!=0) { //alert(boundminx+' > '+maxboundminx+' && '+boundminy+' > '+maxboundminy+' && '+boundmaxx+' <= '+maxboundmaxx+' && '+boundmaxy+' <= '+maxboundmaxy);
									
									if (boundminx > maxboundminx && boundminy > maxboundminy && boundmaxx <= maxboundmaxx && boundmaxy <= maxboundmaxy) {
									
										zwpgx = zwpgx.concat(pgx);
										zwpgy = zwpgy.concat(pgy);
										outlinesx.push(pgx);
										outlinesy.push(pgy);
										pgx.reverse();
										pgy.reverse();
										zwlastcoordinatex.push(pgx[0]);
										zwlastcoordinatey.push(pgy[0]);
									
									} else {
								
										zwlastcoordinatex.reverse();
										zwlastcoordinatey.reverse();
										for (var f=0; f<zwlastcoordinatex.length; f++) {					
											zwpgx.push(zwlastcoordinatex[f]); 
											zwpgy.push(zwlastcoordinatey[f]); 
										}
										xges.push(zwpgx);
										yges.push(zwpgy);
										zwpgx = new Array();
										zwpgy = new Array();
										zwpgx = pgx;
										zwpgy = pgy;
										outlinesx.push(pgx);
										outlinesy.push(pgy);
										
										// get bounding box of the previous element  
			          		maxboundminx = boundminx;
			            	maxboundminy = boundminy;
			            	maxboundmaxx = boundmaxx;
			            	maxboundmaxy = boundmaxy;
			            	
			            	zwlastcoordinatex = new Array();
										zwlastcoordinatey = new Array();
										pgx.reverse();
										pgy.reverse();
										zwlastcoordinatex.push(pgx[0]);
										zwlastcoordinatey.push(pgy[0]);

									}
									
							// 1st polygon or another one (but no island)		
							} else {
										
									// get bounding box of the previous element  
		          		maxboundminx = boundminx;
		            	maxboundminy = boundminy;
		            	maxboundmaxx = boundmaxx;
		            	maxboundmaxy = boundmaxy;
		            	
		            	outlinesx.push(pgx);
									outlinesy.push(pgy);
		            	zwpgx = pgx;
									zwpgy = pgy;
		            	pgx.reverse();
									pgy.reverse();
									zwlastcoordinatex.push(pgx[0]);
									zwlastcoordinatey.push(pgy[0]);
		            	
										
							}	

						
			}	
						
						zwlastcoordinatex.reverse();
						zwlastcoordinatey.reverse();
							for (var f=0 ; f<zwlastcoordinatex.length; f++) {					
								zwpgx.push(zwlastcoordinatex[f]); 
								zwpgy.push(zwlastcoordinatey[f]); 
							}
							
						xges.push(zwpgx);
						yges.push(zwpgy);
						
 							ledit=getObj(editlyr);
							ledit.style.zIndex = thezindex_top;
							ltop=getObj(toplyr);
							ltop.style.zIndex = thezindex_top;
							document.getElementById(divlyr + 'NImG').useMap = '';
				

								js_graphics.setColor(mouse_over_fill_color);
						for (var i=0 ; i<xges.length; i++) {					
										js_graphics.fillPolygon(xges[i],yges[i]); 
						}
						
								js_graphics.setStroke(mouse_over_stroke);
								js_graphics.setColor(mouse_over_stroke_color);
						for (var i=0 ; i<outlinesx.length; i++) {					
										js_graphics.drawPolygon(outlinesx[i],outlinesy[i]); 	
						}
				
						js_graphics.paint();			
			
		}









     function polyXcoords(coords) {

    var Xcoords = '';

    for (var z = 0; z<coords.length; z=z+2) {

        if (z > 0) { Xcoords += ', '; }

            Xcoords += parseInt(coords[z]);

        }

        return Xcoords;

    }

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

                        function polyYcoords(coords) {

                           var Ycoords = '';

                           for (var z = 1; z<coords.length; z=z+2) {

                               if (z > 1) { Ycoords += ', '; }

                                    Ycoords += parseInt(coords[z]);

                                }

                                return Ycoords;

                        }

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

                        function resetImagemapArray() {

                                    doButton('IMAGE_MAP');

                                    js_graphics.clear();

                                    XArray = new Array();                 // empty X array for drawing

                                    YArray = new Array();                 // empty Y array for drawing

                        }

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

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

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


function startCircle(evt,lyr) {
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			boxStartX = imageX;
			boxStartY = imageY;
			boxWidth = 0;
			boxHeight = 0;
			var circleRadius = 0;	
		}
	
	function drawCircle(evt,lyr) {
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			height = getHeight(lyr);	
			width = getWidth(lyr);	
			js_graphics.clear(); // damit jeweils nur ein rahmen sichtbar
			
			
			// if box is going upwards + box is going backwards
				if (boxStartY>imageY && boxStartX>imageX)
				{
					boxWidth = boxStartX - imageX;
					boxHeight = boxStartY - imageY;
				}
				// if box is going downwards + box is going backwards
				if (boxStartY<imageY && boxStartX>imageX) {
					boxWidth = boxStartX - imageX;
					boxHeight = imageY - boxStartY;
				}
				// if box is going upwards + box is going forwards
				if (boxStartY>imageY && boxStartX<imageX) {
					boxWidth = imageX - boxStartX;
					boxHeight = boxStartY - imageY;
				}
				// if box is going downwards + box is going forwards
				if (boxStartY<imageY && boxStartX<imageX) {
					boxWidth = imageX - boxStartX;
					boxHeight = imageY - boxStartY;
				}
				
				// Take biggest radius (from width/height)
				if (boxWidth > boxHeight) {
					 	circleRadius = boxWidth;
					 } else {
					 	circleRadius = boxHeight;
				 }
					
					// Top-X f�r Zeichnen und testen, ob �berall innerhalb extent
					xTestMin = boxStartX - circleRadius;
					if (xTestMin>0) { xPoint = xTestMin; } 
						else { xPoint = 0; circleRadius = boxStartX - 0; }
					xTestMax = boxStartX + circleRadius;
					if (xTestMax<width) { } 
						else { circleRadius = width - boxStartX; xPoint = boxStartX - circleRadius; }
					// Top-Y fuer Zeichnen und testen, ob ueberall innerhalb extent
					yTestMin = boxStartY - circleRadius;
					if (yTestMin>0)  { yPoint = yTestMin; } 
						else { 
							yPoint = 0; 
							circleRadius = boxStartY - yPoint; 
							xPoint = boxStartX - circleRadius; 
						}  
					yTestMax = boxStartY + circleRadius;
					if (yTestMax<height) { } 
						else { circleRadius = height - boxStartY; xPoint = boxStartX - circleRadius; yPoint = boxStartY - circleRadius; }

	
				js_graphics.setColor(color);
				js_graphics.setStroke(stroke);
				js_graphics.drawEllipse(xPoint, yPoint, circleRadius*2, circleRadius*2);
				js_graphics.paint();
	}
	
	function stopCircle(evt,lyr) {
		// if only point
		imageX = getImageX(evt,lyr);
		imageY = getImageY(evt,lyr);
		el = document.forms[theform].elements;

		if ((boxStartY == imageY) && (boxStartX == imageX)) {
			el[theminx].value = boxStartX;
			el[theminy].value = boxStartY;
			el[themaxx].value = boxStartX;
			el[themaxy].value = boxStartY;
			
		}
		// if circle
		else {
			// For Mapscript Zoomin-by-circle
				el[theminx].value = boxStartX;
				el[theminy].value = boxStartY;
				el[themaxx].value = circleRadius;
				el[themaxy].value = '';
		}
		document.forms[theform].submit();
	}

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

		//---------------------------------
		// drawLine
		//---------------------------------
		function drawLine(XArray,YArray) {
				js_graphics.clear();		
				js_graphics.setStroke(stroke);
				js_graphics.setColor(color);
				js_graphics.drawPolyline(XArray,YArray); 
				js_graphics.paint();
			XGeoArray = new Array();
			YGeoArray = new Array();
		}
		//---------------------------------
		//---------------------------------
	
		//---------------------
		// drawMouseLine
		//---------------------
		function drawMouseLine(evt,lyr) {
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			//---------------------
			// Calculate coordinates for DB
			height = getHeight(lyr);	
			width = getWidth(lyr);
			geoMinX=getGeoMinX();
			geoMaxX=getGeoMaxX();
			geoMinY=getGeoMinY();
			geoMaxY=getGeoMaxY();

			XArray[XArray.length] = imageX;
			YArray[YArray.length] = imageY;
					drawLine(XArray,YArray);		// Call drawing function
	
			for (var i=0; i < XArray.length; ++i)
				{ 
					dfPosGeo = myPix2Geo(XArray[i], 0, width, geoMinX, geoMaxX, 0);
					XGeoArray[XGeoArray.length] = dfPosGeo;
					dfPosGeo = myPix2Geo(YArray[i], 0, height, geoMinY, geoMaxY, 1);
					YGeoArray[YGeoArray.length] = dfPosGeo;
				}
//			xyString=convertXY2XYstring(XGeoArray, YGeoArray);
//			el = document.forms[theform].elements;
//			el[thecoord].value = xyString;		// Write coordinates into INPUT FORM TAG for submitting
			//---------------------
		}
		//---------------------------------
		
		//---------------------
		// drawMouseLastLine
		//---------------------
		function drawMouseLastLine(evt,lyr) {
			imageX = getImageX(evt,lyr);
			imageY = getImageY(evt,lyr);
			var xx = new Array();
			var yy = new Array();
			xx = XArray;
			yy = YArray;
		
			if (xx.length<2) {  } else {
				xx.pop();
				yy.pop();
			}

			xx[xx.length] = imageX;
			yy[yy.length] = imageY;
			//---------------------
			js_graphics.clear();
			drawLine(xx,yy);		// Call drawing function
				}
		//---------------------------------
		
//---------------------
	// stopRulerAction() 
	//---------------------
	function stopRulerAction() {
		el = document.forms[theform].elements;
	 	el[thetool].value = '';
		ruling=0;
	}

	//---------------------
	// calculateLines()
	//---------------------
	function calculateLines(XArray,YArray) {
		distance_array = new Array();
		var distance_sum = 0;
		for (var i=1; i < XArray.length; ++i)
			{
				var dist_x; var dist_y; var delta_diff;
				dist_x = Math.abs(XArray[i-1] - XArray[i]);
				dist_y = Math.abs(YArray[i-1] - YArray[i]);
				delta_diff = Math.sqrt((Math.pow(dist_x, 2) + Math.pow(dist_y, 2)));
				distance_array[distance_array.length] = parseInt(delta_diff);
				distance_sum += parseInt(delta_diff); 
			}
			
			return calculateDistance(distance_sum,delta_diff);
	}

	//---------------------
	// calculateDistance()
	//---------------------
	function calculateDistance(distance_total,distance_lastsegment) {
		el = document.forms[theform].elements;
		  var scale = el[thescale].value;
		  // c = 1 / 72 / 12 
		  var c = 0.00035276056;	// konstante
		  var f = scale * c;	// scale factor
		  var t = (f * distance_total)/1000;	// total km
		//var s = f * distance_lastsegment;	// last segment
		//window.status = parseInt(t) + ' ' + parseInt(s);
		el[thedistance].value = parseInt(t);
	}
	
	//---------------------------------
	// Convert xArray and yArray into xyString (for PostGIS)
	//---------------------------------
	function convertXY2XYstring(xArray, yArray) {
		xyArray = new Array();
		for (var i=0; i < xArray.length; ++i)
			{
			xyArray[xyArray.length] = xArray[i] + ' ' + yArray[i];
			}
		var xyString = xyArray.join(",");
		return xyString;	
		}
	//---------------------------------

	//---------------------------------
	// Convert xyString into xArray and yArray (from PostGIS)
	//---------------------------------
	
	function convertXYString2XY(xyString) {
		xArray = new Array();
		yArray = new Array();

		var ins=xyString.split(",");

		for (var i=0; i < ins.length; ++i)
		{
			var inin=ins[i].split(" ");
			xArray[xArray.length] = inin[0];
			yArray[yArray.length] = inin[1];
		}
		
		xyArray = new Array(xArray,yArray);
		return xyArray;	
	}

	//-------------------------------------
	//	Write from function to INPUT-TAG of FORM
	//-------------------------------------
	function myFormOutput(form_name,input_name,input_value) {
		el = document.forms[form_name].elements;
		el[input_name].value = input_value;
	}
	//-------------------------------------
	//-------------------------------------
	//	Get value from INPUT-TAG of FORM
	//-------------------------------------
	function myFormInput(form_name,input_name) {
		el = document.forms[form_name].elements;
		return el[input_name].value;
	}
	//-------------------------------------
	//-------------------------------------
	//	SET redraw_x INPUT-TAG to redraw_x
	//-------------------------------------
	function mySetRedraw(form_name) {
		el = document.forms[form_name].elements;
		el['redraw_x'].value = 'redraw_x';
	}