var NONE=0, RESIZING=1, RESIZINGLEGEND=2, DRAGGING=3, PANNING=4, DRAGGINGCTRL=5, DIGITIZING=6;
var RECT=1, CIRCLE=2, POLY=3, SLIDER=4, SCALE=6, TOOLBAR=7;
var moveType = NONE, dragElt = 0, digiType;
var anchorX, anchorY, rlAnchor, inctrlX=0, inctrlY=0, lastposx, lastposy;
var mapPosX = 0; // mapPosX = 200; (ursprünglich) // Breites des ScalebarImages = 51px
var toolbarPosX = 51;    //Breite des Toolbarimages = 112px
var showSlider=true;
var sliderx=10, slidery=43 // Position Slider von linker oberer Ecke (hier 0, wird on window.js gesetzt)
var sscalex=0, sscaley=0; // Position SliderScale von linker oberer Ecke (hier 0, wird on window.js gesetzt)
var toolbarx=0, toolbary=0; // Position SliderScale
var slidercourse = 78;
var slidertop = 43; //slidertop = 44;
var minScale = 0.001, maxScale = 100000000;
var curScale = 0, tmpScale = 0, sci = 0;
var moveFactor, zoomFactor;

//Beinhaltet des Kommando welches ausgeführt werden soll (zoomRechteck,info,...) bezüglich Toolbar
var MAP_NONE=0, MAP_MOVE=1, MAP_ZOOMRECTANGLE=2, MAP_INFO=3;
var executeCommand = MAP_MOVE;
var initToolbarImage = true;    //wird bei initialisieren der Tools 1 Mal mit true benötigt

function InitToolPosition(force) {  

    if(force || sscalex == 0)
    {
        //Position der Karte abrufen und speichern
        oMapPos = getElementPosition(document.getElementById(MapControl_MapContainer));

        sscalex = oMapPos.left //+ getContainerWidth();
        sscaley = oMapPos.top; 
        
        toolbarx = sscalex;
        toolbary = sscaley;

        sliderx = sscalex + 10;
        slidery = sscaley + 43;
                

        MoveMapControl("sliderscale", mapPosX, sscalex, sscaley);
        MoveMapControl("slider", mapPosX, sliderx, slidery);
        MoveMapControl("toolbar", mapPosX + toolbarPosX , sscalex, sscaley);
    }
}


function OnSliderImageLoaded(imgName, setToolbarImage) {
    img = document.getElementById(imgName);
    if(!showSlider) {
        img.parentNode.style.visibility = "hidden";
        return;
    }
    
    // Setzen des entsprechenden Images der ToolBar
    if(initToolbarImage == true && imgName == "toolbarimg")
    {
        //damit beim nach dem Ändern des Source Attributs nicht nochmal das Switch-Case ausgeführt wird
        initToolbarImage = false;
        
        //entsprechend ExecuteCommand das ToolbarImage setzen
        switch(executeCommand) {
            case MAP_MOVE:
                 img.src = "WebMap_gifs/ToolbarH.png";
                 break;
            case MAP_ZOOMRECTANGLE:
                img.src = "WebMap_gifs/ToolbarR.png";
                break;
            case MAP_INFO: 
                img.src = "WebMap_gifs/ToolbarI.png";
                break;
            default:
                img.src = "WebMap_gifs/ToolbarN.png";
                break;                            
        }
        return;
    }    

    // Initialisiere der Tools
    InitToolPosition(false);   
    
    if(!msie)
        return;
        
    //Auslesen der Breite und Höhe des Containerelements
    var pHeight = img.parentElement.style.height;
    var pWidth = img.parentElement.style.width;
        
    strGif = "WebMap_gifs/transparentpixel.gif";
    var imgID = (img.id) ? "id='" + img.id + "' " : "";
    var imgClass = (img.className) ? "class='" + img.className + "' " : "";
    var imgTitle = (img.title) ? "title='" + img.title + "' " : "title='" + img.alt + "' ";
    var imgStyle = "display:inline-block;" + img.style.cssText ;
    if (img.align == "left") imgStyle = "float:left;" + imgStyle;
    if (img.align == "right") imgStyle = "float:right;" + imgStyle;
    if (img.parentElement.href) imgStyle = "cursor:pointer;" + imgStyle;
    if (img.useMap) {
        strAddMap = "<img style=\"position:absolute; left: 0px; top: 0px; height:" + pHeight + "; width:" + pWidth + ";\" " + "src=\"" + strGif + "\" usemap=\"" + img.useMap  + "\" border=\"" + img.border + "\">";
    }

    var strNewHTML = "<span " + imgID + imgClass + imgTitle + " style=\"" + "width:" + pWidth + "; height:" + pHeight + ";" + imgStyle + ";" + "filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'" + img.src + "\', sizingMethod='crop');\"></span>"     
    
    if (img.useMap) strNewHTML += strAddMap;
    img.outerHTML = strNewHTML;
}

//wird beim Klick auf SliderScale-Image ausgeführt
function ClickSliderScale(e) {

    x = (msie?event.clientX: e.clientX) - mapPosX;
    y = (msie?event.clientY: e.clientY);
    if(msie) e.cancelBubble = true; else e.stopPropagation();

    moveType = DRAGGINGCTRL;
    dragElt = SCALE;
    anchorX = x;
    anchorY = y;
    return false;
}

//Klick auf Verschiebefläche der Toolbar
function ClickToolbar(e) {
    x = (msie?event.clientX: e.clientX) - mapPosX;
    y = (msie?event.clientY: e.clientY);
    if(msie) e.cancelBubble = true; else e.stopPropagation();

    moveType = DRAGGINGCTRL;
    dragElt = TOOLBAR;
    anchorX = x;
    anchorY = y;
    return false;
}

//wird beim Klick auf Slider-Image ausgeführt
function ScaleSliding(e) {
    moveType = DRAGGINGCTRL;
    dragElt = SLIDER;
    anchorY = e.screenY;
    if(msie) e.cancelBubble = true; else e.stopPropagation();
    return false;
}

function DragMapControls(e, page) {
    switch(dragElt)
    {
        case SLIDER:
            DragSlider(e.screenY);
            break;
        case SCALE:
            DragSliderScale(e, page);
            break;
        case TOOLBAR:
            DragToolbar(e, page);
            break;
    }
}

function DragSlider(y) {
    sliderPos = CalcSliderPos(y);
    document.getElementById("slider").style.top = sliderPos + "px";
    
    // Eigene Entwicklung
    ZoomScale(ScaleIndexFromSliderPos(sliderPos));
    // ShowScaleTip(sliderx + mapPosX, sliderPos, scale);
    return false;
}
function DragSliderScale(e, page) {
    if(page)
        d = mapPosX;
    else
        d = 0;
    x = e.clientX;
    if(x < d + inctrlX)
        x = d + inctrlX;
    x -= d;
    y = e.clientY;

    offsX = x - anchorX;
    offsY = y - anchorY;
    
    MoveMapControl("sliderscale", mapPosX, sscalex + offsX, sscaley + offsY);
    MoveMapControl("slider", mapPosX, sliderx + offsX, slidery + offsY);
}

function DragToolbar(e, page) {
if(page)
        d = mapPosX;
    else
        d = 0;
    x = e.clientX;
    if(x < d + inctrlX)
        x = d + inctrlX;
    x -= d;
    y = e.clientY;

    offsX = x - anchorX;
    offsY = y - anchorY;
    
    MoveMapControl("toolbar", mapPosX + toolbarPosX, toolbarx + offsX, toolbary + offsY);
}

function ReleaseMapControls(e) {
    moveType = NONE;
    switch(dragElt)
    {
        case SLIDER:
            ReleaseSlider(e.screenY);
            break;
        case SCALE:
            ReleaseSliderScale(e);
            break;
        case TOOLBAR:
            ReleaseToolbar(e);
            break;
    }
    dragElt = NONE;
}

function MoveMapControl(eltId, offsx, x, y) {
    if(!showSlider)
        return;
    var element = document.getElementById(eltId)
    
    if(element != null) 
    {
        var style = element.style;
        style.left = (offsx + x)+"px";
        style.top = y+"px";
        style.position = "absolute";
        style.visibility = "visible";
    }
}
function ReleaseSlider(y) {
    //HideScaleTip();
    slidery = CalcSliderPos(y);
    document.getElementById("slider").style.top = slidery + "px";
    
    // Eigene Entwicklung
    ZoomMap();
}
function ScaleIndexFromSliderPos(pos) {
    sp = pos - sscaley - slidertop;
    return sp;
    //index = parseInt(sp / slidercourse * (scales.length - 1));
    //return index;
}
function ReleaseSliderScale(e) {
    x = e.clientX;
    if(x < mapPosX + inctrlX)
        x = mapPosX + inctrlX;
    x -= mapPosX;
    y = e.clientY;

    offsx = x - anchorX, offsy = y - anchorY;
    sscalex += offsx;
    sscaley += offsy;
    sliderx += offsx;
    slidery += offsy;

    MoveMapControl("sliderscale", mapPosX, sscalex, sscaley);
    MoveMapControl("slider", mapPosX, sliderx, slidery);
}
function ReleaseToolbar(e) {
    x = e.clientX;
    if(x < mapPosX + inctrlX)
        x = mapPosX + inctrlX;
    x -= mapPosX;
    y = e.clientY;

    offsx = x - anchorX, offsy = y - anchorY;
    toolbarx += offsx;
    toolbary += offsy;
    
    MoveMapControl("toolbar", mapPosX + toolbarPosX, toolbarx, toolbary);
}
function CalcSliderPos(y) {
    offs = y - anchorY;
    newPos = slidery + offs;
    if(newPos < sscaley + slidertop)
        newPos = sscaley + slidertop;
    else if (newPos > sscaley + slidertop + slidercourse)
        newPos = sscaley + slidertop + slidercourse;
    return newPos;
}
function SetScaleSliderPos() {
    newPos = slidercourse - (maxScale-curScale) * slidercourse / (maxScale-minScale);    
    
    slidery = sscaley + slidertop + Math.round(newPos);
    var element = document.getElementById("slider");
    
    if(element != null) element.style.top = slidery +"px";    
}

function OnMouseMove(e) {
    var x = e.clientX - mapPosX;
    var y = e.clientY;
    lastposx = x; lastposy = y;

    if(moveType == RESIZING)
        ResizeTo(e.clientX);
    else if(moveType == DRAGGING)
        ToolFeedback(x, y);
    else if(moveType == RESIZINGLEGEND)
        ResizeLegendTo(msie?event.screenY: e.screenY);
    else if(moveType == PANNING)
        PanFeedback(e);
    else if(moveType == DRAGGINGCTRL)
        DragMapControls(e, true);
    else
    {
    }
    return false;
}

function OnMouseUp(e) {
    var x = e.clientX - mapPosX;
    var y = e.clientY;
    if(msie) e.cancelBubble = true; else e.stopPropagation();

    lastposx = x; lastposy = y;

    if(moveType == DRAGGINGCTRL)
        ReleaseMapControls(e);
}

function ZoomScale(pos)
{
    var offsetTop = pos;
    var deltaScale = maxScale-minScale;

    var newScale = pos*deltaScale/slidercourse+maxScale-deltaScale;
    
    var mapWidth = getContainerWidth();
    var mapHeight = getContainerHeight();

    var zoomFaktor = curScale/newScale;
    
    var newWidth = parseInt(mapWidth * zoomFaktor);
    var newHeight = parseInt(mapHeight * zoomFaktor);
    
    var xPos =  parseInt(-1*(newWidth-mapWidth) / 2);
    var yPos =  parseInt(-1*(newHeight-mapHeight) / 2);
    
    getMap().style.width = newWidth+"px";
    getMap().style.height = newHeight+"px";
    getMap().style.left = xPos+"px";
    getMap().style.top = yPos+"px";
    getMap().style.position = "absolute";
    
    tmpScale = Math.round(newScale);
}

function ZoomMap()
{
    // Aufruf des AjaxWebServices
	getMapRequestByScale(Math.round(tmpScale));
	curScale = Math.round(tmpScale);
}

function ZoomCloser(e) {
    if(msie) e.cancelBubble = true; else e.stopPropagation();

    // Aufruf des AjaxWebServices
	getMapRequestByZoom('in');
	
	var mapWidth = getMapWidth();
    var mapHeight = getMapHeight();
	
	var newWidth = parseInt(mapWidth / zoomFactor);
    var newHeight = parseInt(mapHeight / zoomFactor);
    
    var xPos =  parseInt(-1*(newWidth-mapWidth) / 2);
    var yPos =  parseInt(-1*(newHeight-mapHeight) / 2);
    
    getMap().style.width = newWidth+"px"; 
    getMap().style.height = newHeight+"px";
    getMap().style.left = xPos+"px";
    getMap().style.top = yPos+"px";
    getMap().style.position = "absolute";	
    return false;
}
function ZoomFurther(e) {
    if(msie) e.cancelBubble = true; else e.stopPropagation();

    // Aufruf des AjaxWebServices
    getMapRequestByZoom('out');
    
    var mapWidth = getMapWidth();
    var mapHeight = getMapHeight();
    
    var newWidth = parseInt(mapWidth * zoomFactor);
    var newHeight = parseInt(mapHeight * zoomFactor);
    
    var xPos =  parseInt(-1*(newWidth-mapWidth) / 2);
    var yPos =  parseInt(-1*(newHeight-mapHeight) / 2);
    
    getMap().style.width = newWidth+"px";
    getMap().style.height = newHeight+"px";
    getMap().style.left = xPos+"px";
    getMap().style.top = yPos+"px";
    getMap().style.position = "absolute";    
    return false;
}

function OnPan(e, dir) {
    if(msie) e.cancelBubble = true; else e.stopPropagation();
    
    // Aufruf des AjaxWebServices
    getMapRequestByMove(dir);
    
	var map = getMap();
	var mapHeight = map.offsetHeight;
	var mapWidth = map.offsetWidth;
	var mapTop = parseInt(map.style.top);
	var mapLeft = parseInt(map.style.left);
	
	map.style.position = "relative";
    switch(dir) {
        case 0: map.style.top = (mapTop+mapHeight*moveFactor)+"px"; break;
        case 1: map.style.left = (mapLeft+mapWidth*moveFactor*(-1))+"px"; break;
        case 2: map.style.top = (mapTop+mapHeight*moveFactor*(-1))+"px"; break;
        case 3: map.style.left = (mapLeft+mapWidth*moveFactor)+"px"; break;
    }
    return false;
}

//wird beim Klick auf Slider-Image ausgeführt
function ExecButtonCommand(e, command) {
    
    if(msie) 
        e.cancelBubble = true; 
    else 
         e.stopPropagation();
    
    var imgName =  "";
    
    moveType = NONE;
    dragElt = NONE;       
    
    switch(command) {
        case "MOVE":
            executeCommand = MAP_MOVE;
            imgName = "WebMap_gifs/ToolbarH.png";
            break;
        case "ZOOM":
            executeCommand = MAP_ZOOMRECTANGLE;
            imgName = "WebMap_gifs/ToolbarR.png";
            break;
        case "INFO":
            executeCommand = MAP_INFO;
            imgName = "WebMap_gifs/ToolbarI.png";
            break;
        default:
            window.alert("Kein Command hinterlegt");
            imgName = "WebMap_gifs/ToolbarN.png";
            executeCommand = MAP_NONE;
            break;
    }
    
    // Command auf Server setzen
    var request = CreateRequest(); 
    request.open('get', 'WebMap_service/Wms.asmx/SetMapCommand?CommandName='+executeCommand);
    request.send(null);
    
    // Info setzen
    function ret() {}
    var infoMap = document.getElementById("InfoMap");
    if (infoMap!=null) 
    {
        var areaColl = infoMap.getElementsByTagName("AREA");
        for (i=0;i<areaColl.length;i++)
        {
            if (executeCommand == MAP_INFO) 
                areaColl.item(i).setAttribute("href","javascript:ret()");
            else
            {
                areaColl.item(i).removeAttribute("href");
                if (!msie) 
                {
                    var oNewNode = areaColl.item(i).cloneNode(true);
                    infoMap.replaceChild(oNewNode,areaColl.item(i));
                }
            }
        }
    }
    
    if(msie)
        document.getElementById("toolbarimg").style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'" + imgName + "\', sizingMethod='crop');\"";
    else {
        document.getElementById("toolbarimg").src = imgName;             
    }       
         
    return false;   
}

// Funktion die nicht zurückgibt: Zeile:473
function ret() {}

function CreateRequest() 
{
    var ro;
    var browser = navigator.appName;
    ro = (browser == "Microsoft Internet Explorer") ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
    return ro;
}


//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//
//                      FRÜHER WINDOWS.JS
//
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************

// Die Koordinaten des aufzuziehenden Fensters in Bildschirmkoordinaten
var beginTrackMapx, beginTrackMapy, endTrackMapx, endTrackMapy;

// Variablen, die den Startwert für das Verschieden des Kartenbildes aufnehmen
var beginPanMapX, beginPanMapY, endPanMapX, endPanMapY;

// Status des Fensteraufziehens
var isTracking = false;

// Bildkoordinaten (linksoben) werden für Netscape benötigt, da 'event' immer
// nur die Bildschirmposition zurückgibt (IE gibt Bildkoordinaten zurück)
var oSubmitTimer = "";

//Position der Karte absolut zum Fenster
var oMapPos;

// Das Objekt, welches den ClickEvent ausgelöst hat 
// Objekt wird benötigt, da nicht immer die Karte der Auslöser ist, sondern 
// eventuell ein Tooltip oder der Copyrightvermerk
var clickedObj = null;

function getContainer()
{
    return document.getElementById(MapControl_MapContainer);
}

function getContainerWidth()
{
    return getContainer().offsetWidth;
}
function getContainerHeight()
{
    return getContainer().offsetHeight;
}

function getMapWidth()
{
    return document.getElementById(MapControl_WMSMap).offsetWidth;
}
function getMapHeight()
{
    return document.getElementById(MapControl_WMSMap).offsetHeight;
}

//Setzen der dokumentweiten Eventhandler zum Abfangen des Kartenklicks
if(ns4)
{
	document.captureEvents(Event.MOUSEDOWN)
	document.captureEvents(Event.MOUSEMOVE)
	document.captureEvents(Event.MOUSEUP)
	document.captureEvents(Event.KEYDOWN)
}
else
{
	document.onmousedown = onDocumentClicked;
	document.onmousemove = onDocumentMovedOver;
	document.onmouseup = onDocumentReleased;
//	document.onkeydown = onDocumentKeyDown;
	document.onmousewheel = onMouseWheeleHandler;
	window.onresize = onResizeMap;
}

function getMap()
{
	// Verweis auf das Kartenobjekt
	imgRef = (ie) ? document.all[MapControl_WMSMap] : document.getElementById(MapControl_WMSMap);
	return imgRef;
}

function onResizeMap()
{        
    // Timeout setzen für das Abschicken der Karte
    // Zuücksetzen des Timers
    if (oSubmitTimer != "") window.clearTimeout(oSubmitTimer);
    {     
        // resizeViewerFrame()
        
        // Clippen der Karte
        var width = getContainerWidth();
        var height = getContainerHeight();
        document.getElementById(MapControl_MapClip).style.clip = "rect(0px "+width+"px "+height+"px 0px)";
        
        // Timer setzen
        oSubmitTimer = window.setTimeout("checkMapSize()",500);        
    }
}

function resizeViewerFrame()
{
    var viewerFrame = document.getElementById("mapframe");
    if (viewerFrame!=null) 
    {
        var viewerFramePos = getElementPosition(viewerFrame);
        
        // Neue Höhe zuweisen
        height = document.documentElement.offsetHeight-viewerFramePos.top-40;
        viewerFrame.style.height = height+"px";
        viewerFrame.style.display = "block";
        
        // Workaround für IE6 : Bei Resize der Kartendarstellungsbox via Script
        // ziehen die untergeordneten Elemente nicht mit, obwohl sie 100% Ausdehnung haben
        // daher muss der Prozeß von Hand angestoßen werden
        if (msie6)
        {
            viewerFrame.getElementsByTagName("div").item(0).style.height = "auto"; 
            viewerFrame.getElementsByTagName("div").item(0).style.height = "100%"       
        }
    }
}

//***********************************************************************
// EVENTHANDLER für document.onmousedown
//***********************************************************************
function onDocumentClicked(evt)
{
	var ret = true;
	var x, y, xtrack, ytrack;
	var mapWidth, mapHeight;
	
	// Event abfragen und das geklickte Element ermitteln
	evt = (evt) ? evt : window.event ;
	clickedObj = (evt.srcElement) ? evt.srcElement : evt.target;
	
	if (getMap())
	{
		if(ns4 || ns6)
		{
			mapWidth	= imgRef.offsetWidth;
			mapHeight	= imgRef.offsetHeight;
		}	
		else if (ie)
		{
			mapWidth	= imgRef.width;
			mapHeight	= imgRef.height;
		}
	}
	else
	    return false;	    
	
	if(ns4 || ns6)
	{
		if (evt.which == 2 || evt.which == 3)
			return true;
		
		var mousex = evt.pageX;
		var mousey = evt.pageY;

		// Wenn der Click in den Grenzen der Karte fällt
		if(mousex > oMapPos.left && mousex < (oMapPos.left + mapWidth) && 
			mousey > oMapPos.top && mousey < (oMapPos.top + mapHeight))
		{
		    x = (evt.pageX - oMapPos.left) < 0 ? 0 : evt.pageX - oMapPos.left;
			y = mapHeight - ((evt.pageY - oMapPos.top) < 0 ? 0 : evt.pageY - oMapPos.top);
					
			if(ns4)
			{
				xtrack = x;
				ytrack = mapHeight - y;
			}
			else
			{
				xtrack = evt.pageX;
				ytrack = evt.pageY;
			}
			ret = false;
		}
		else
			return true;
	}
	else
	{
		if (evt.button == 2 || evt.button == 3)
			return false;
			
		var mousex = evt.clientX+document.body.scrollLeft;
		var mousey = evt.clientY+document.body.scrollTop;

		// Wenn der Click in den Grenzen der Karte fällt
		if(mousex > oMapPos.left && mousex < (oMapPos.left + mapWidth) && 
			mousey > oMapPos.top && mousey < (oMapPos.top + mapHeight))
		{
			x = mousex - oMapPos.left; 
			y = (oMapPos.top + mapHeight) - mousey; 
			xtrack = mousex;
			ytrack = mousey;
			ret = false;
	
		}
		else
			return true
	}
	
	//user has clicked the map and we got the x and y coordinate of the point, relative to the map
	//find out the command to execute
	
	// Aufgrund des aktiven Karten-Buttons werden die Werte gespeichert
	switch(executeCommand)
	{
		case MAP_ZOOMRECTANGLE: // Zoom to Window
			beginTrackMapx = endTrackMapx = x;
			beginTrackMapy = endTrackMapy = y;
			startTracking(xtrack, ytrack);
			break;
		case MAP_MOVE: // Move map
			beginPanMapX = endPanMapX = x;
			beginPanMapY = endPanMapY = y;
			isTracking = true;			
			break;
		case MAP_INFO: // Info from map
			beginTrackMapx = endTrackMapx = xtrack - oMapPos.left;
			beginTrackMapy = endTrackMapy = ytrack - oMapPos.top;
			isTracking = true;
			break;	
		default:
			break
	}
	
	return ret;
}

//***********************************************************************
// EVENTHANDLER für document.onmousemove
//***********************************************************************
function onDocumentMovedOver(evt)
{
    var mapWidth, mapHeight;
    
    // Aufruf für den neuen Slider
    if(moveType == DRAGGINGCTRL)
    {
        if (msie) evt = window.event;
        OnMouseMove(evt);
        
        return true;
    }
    
    if(!isTracking) return true;
    
    mapWidth = getMapWidth();
    mapHeight = getMapHeight();
    
    if(ns4 || ns6)
	{
		var mousex = evt.pageX;
		var mousey = evt.pageY;
		
		// Wenn der Click in den Grenzen der Karte fällt
		
		if(mousex > oMapPos.left && mousex < (oMapPos.left+mapWidth) && 
			mousey > oMapPos.top && mousey < (oMapPos.top+mapHeight))
		{
			// Aufgrund des aktiven Karten-Buttons werden die Werte gespeichert
			switch(executeCommand)
			{
				case MAP_ZOOMRECTANGLE: // Zoom to Window

					// Setzen der Bildkoordinaten für den Endpunkt (von links unten)
					endTrackMapx = (evt.pageX - oMapPos.left) < 0 ? 0 : evt.pageX - oMapPos.left;
					endTrackMapy = mapHeight - ((evt.pageY - oMapPos.top) < 0 ? 0 : evt.pageY - oMapPos.top);
					
					// Zeichnen des aufgezogenen Rechtecks (absolute Bildschirmkoordinaten von links oben)
					if(ns4) // noch nicht geändert
						drawTrackRect(trackPosx, trackPosy, endTrackMapx, mapHeight - endTrackMapy);
					else
						drawTrackRect(trackPosx, trackPosy, mousex, mousey);					
				
					break;
					
				case MAP_MOVE: // Move map
					// Setzen der Bildkoordinaten für den aktuellen Zeigerpunkt(von links unten)
					endPanMapX = (evt.pageX - oMapPos.left) < 0 ? 0 : evt.pageX - oMapPos.left;
					endPanMapY = mapHeight - ((evt.pageY - oMapPos.top) < 0 ? 0 : evt.pageY - oMapPos.top);
					
					var map = document.getElementById(MapControl_WMSMap);
					
					map.style.position = "relative";
					map.style.left = (endPanMapX-beginPanMapX)+"px";
					map.style.top = -1*(endPanMapY-beginPanMapY)+"px";
					break;						    				
				default:
					break
			}
		}
	}
	else
	{

		var mousex = window.event.clientX+document.body.scrollLeft;
		var mousey = window.event.clientY+document.body.scrollTop;

		// Wenn der Click in den Grenzen der Karte fällt
		if(mousex > oMapPos.left && mousex < (oMapPos.left + mapWidth) && 
			mousey > oMapPos.top && mousey < (oMapPos.top + mapHeight))
		{
		    if(window.event.srcElement.id);
		    
			// Aufgrund des aktiven Karten-Buttons werden die Werte gespeichert
			switch(executeCommand)
			{
				case MAP_ZOOMRECTANGLE: // Zoom to Window
					// Setzen der Bildkoordinaten für den Endpunkt (von links unten)
					endTrackMapx = mousex-oMapPos.left;
					endTrackMapy = (oMapPos.top+mapHeight) - mousey;
					
					// Zeichnen des aufgezogenen Rechtecks (absolute Bildschirmkoordinaten von links oben)
					drawTrackRect(trackPosx, trackPosy, mousex, mousey);					
					break;
					
				case MAP_MOVE: // Pan map
					// Setzen der Bildkoordinaten für den aktuellen Zeigerpunkt(von links unten)
					endPanMapX = mousex-oMapPos.left;
					endPanMapY = (oMapPos.top+mapHeight) - mousey;
					
					var map = document.getElementById(MapControl_WMSMap);
					map.style.position = "relative";
					map.style.left = (endPanMapX-beginPanMapX)+"px";
					map.style.top = -1*(endPanMapY-beginPanMapY)+"px";
					break;					    
				default:
					break
			}
		}
	}	
 
   	return false;
}

//***********************************************************************
// EVENTHANDLER für document.onmouseup
//***********************************************************************
function onDocumentReleased(evt)
{
    // Aufruf für den neuen Slider
    if(moveType == DRAGGINGCTRL)
    {
        if (msie) evt = window.event;
        OnMouseUp(evt);
        
        return true;
    }
    
    // Wenn es das Feld MapCommand nicht gibt (keine Karte sichtbar)
	if (executeCommand == NONE) return false;
	
	// Event abfragen und das geklickte Element ermitteln
	Event = (evt) ? evt : window.event ;
	var SrcElement = (Event.srcElement) ? Event.srcElement : Event.target
		
	if(isTracking)
	{	
		//remove tracking rect
		isTracking = false;
		
		// Aufgrund des aktiven Karten-Buttons werden die Werte gespeichert
		switch(executeCommand)
		{
			case MAP_ZOOMRECTANGLE: // Zoom to Window			
				// Rechteck ausblenden
				terminateTracking();                
                // Aufruf des AjaxWebServices
				getMapRequestByExtent(beginTrackMapx,beginTrackMapy,endTrackMapx,endTrackMapy);				
				break;				
			case MAP_MOVE: // Pan map				
				// Aufruf des AjaxWebServices
                getMapRequestByPan(beginPanMapX,beginPanMapY,endPanMapX,endPanMapY);				    				
				break;				
			case MAP_INFO :						
				// Aufruf des AjaxWebServices
			    getMapRequestByInfo(SrcElement.id,beginTrackMapx, beginTrackMapy);			
		        break;		               
			default:
				break
		}
	}
		
   	return true;
}

var countX = -1;
var countY = -1;

//***********************************************************************
// EVENTHANDLER für document.onmousewheele
//***********************************************************************
function onMouseWheeleHandler()
{ 
    if(msie && event.srcElement.id == MapControl_WMSMap)
    {   
        //wenn über Karte Mausrad bewegt wird, soll nicht das Fenster verschoben werden, sondern
        //Karte gezoomt
        return false;
    }
    else
    {
        return true;
    }
}

function GetOnMouseWheel(evt)
{
    // Wenn FF dann ist e ein Objekt
    evt = (typeof(evt) != 'undefined') ? evt : null;

    // Count wird beim Initialisieren auf die Größe der Karte gesetzt
    if (countX==-1) countX = getContainerWidth();
    if (countY==-1) countY = getContainerHeight();
    
    // Neue Werte ermitteln
	countX = Counting(evt,countX);
	countY = Counting(evt,countY);

	// Kartengröße verändern
	Resize(evt);
	
	return false;
}

function Counting(evt,count){   

    var direction = (evt != null) ? evt.detail*(-1) : event.wheelDelta;

    if (direction > 0)
        count = Math.round(count+(count*10/100))*1.2;
    else if (direction < 0)
        count = Math.round(count-(count*10/100))/1.2;   
        
    return count; 
}

function Resize(evt){    
    // Verweis auf das event
    evt = (evt) ? evt : window.event ;
	srcElement = (evt.srcElement) ? evt.srcElement : evt.target;
	    
    // Zuücksetzen des Timers
    if (oSubmitTimer != "") window.clearTimeout(oSubmitTimer);
    
    // Differenz der Größenänderung der Karte in beiden Richtungen
    var dMapWidth = parseInt(getMap().offsetWidth) - countX;
    var dMapHeight = parseInt(getMap().offsetHeight) - countY;
    
    // Faktor zum Platzieren des geklickten Punktes am Mauscursor
    
    if (firefox2)
    {
        // WORKAROUND für Fierefox 2.0: https://bugzilla.mozilla.org/show_bug.cgi?id=352179
        //alert("firefox2");
        var xOffsetScale = srcElement.offsetWidth/((window.event)?evt.offsetX:Math.round((evt.pageX-8)/15));
        var yOffsetScale = srcElement.offsetHeight/((window.event)?evt.offsetY:Math.round((evt.pageY-8)/15));
    }
    else if (firefox3)
    {
        //alert("firefox3");
        var xOffsetScale = srcElement.offsetWidth/((window.event)?evt.offsetX:evt.pageX-getElementPosition(srcElement).left);
        var yOffsetScale = srcElement.offsetHeight/((window.event)?evt.offsetY:evt.pageY-getElementPosition(srcElement).top);
    }
    else
    {
        //alert("msie");
        var xOffsetScale = srcElement.offsetWidth/evt.offsetX;
        var yOffsetScale = srcElement.offsetHeight/evt.offsetY;
    }
 
    // Um diesen Wert muß die Karte bei Größenänderung, um Ihren ursprünglichen Wert verschoben werden
    var xMapOffset = dMapWidth / xOffsetScale;
    var yMapOffset = dMapHeight / yOffsetScale;
   
    // Abstand vom linken und oberen Rand des Containers vor der Größenänderung der Karte
    var xOffset = (srcElement.style.left!="") ? parseInt(srcElement.style.left) : 0;
    var yOffset = (srcElement.style.top!="") ? parseInt(srcElement.style.top) : 0;

    // Bestimmen der neuen absoluten Positionen zum Container
    var xPos = Math.round(xOffset + xMapOffset);
    var yPos = Math.round(yOffset + yMapOffset);

    // Setzen der neuen Größe der Karte
    getMap().style.width = countX+"px";
    getMap().style.height = countY+"px"; 
    
    // Setzen der neuen Position der Karte        
    getMap().style.left = xPos+"px";
    getMap().style.top = yPos+"px";
    getMap().style.position = "absolute";
    
    // Timeout setzen für das Abschicken der Karte
    oSubmitTimer = window.setTimeout("SubmitOnMouseWheel("+countX+","+countY+","+xPos+","+yPos+")",500);
    
    // Firefox: verhindern von Defaultaktionen (Fenster scrollen)
    if (evt.preventDefault)
          evt.preventDefault();
	evt.returnValue = false;
}

function SubmitOnMouseWheel(width,height,left,top)
{
    
    // Wenn der Timer aktiviert ist
    if (oSubmitTimer!="")
    {
        var mapWidth = getContainerWidth();
        var mapHeight = getContainerHeight();
        
        // Zurücksetzen des Timeouts
        window.clearTimeout(oSubmitTimer);
        
        // Übernahme der Koordinaten des gezoomten Kartenausschnitts in Bildschirmkoordinaten
        var x1 = left;
		var x2 = left+width;
		var y1 = mapHeight+(top*(-1))-height;
		var y2 = mapHeight+(top*(-1));
		
		var xratio = Math.abs(parseFloat(left+width) - parseFloat(left)) / parseFloat(mapWidth);
        var yratio = Math.abs(parseFloat(mapHeight+(top*(-1))) - parseFloat(mapHeight+(top*(-1))-height)) / parseFloat(mapHeight);

        // Berechnen der neuen Bildschirmkoordinaten, 
        // sowie wenn ein Fenster aufgezogen worden wäre (Berücksichtigung, das auch 
        // negative Werte auftreten können)
        x1 = parseInt((-1) * parseInt(x1) / xratio);
        x2 = mapWidth - parseInt((parseInt(x2) - mapWidth) / xratio);
        y1 = parseInt((-1) * parseInt(y1) / yratio);
        y2 = mapHeight - parseInt((parseInt(y2) - mapHeight) / yratio);
        
        // Karte anfordern
        getMapRequestByExtent(x1,y1,x2,y2);
        
        // Die Counter für das Mausrad wieder zurücksetzen
        countX = -1;
        countY = -1;
        count = -1;
        
        // Timer zurücksetzen
        oSubmitTimer="";       
    }
}

// Allgemeine Funktion zum Bestimmen von Positionen von Objekten zum absoluten 
// Seitennullpunkt
function getElementPosition(oElem)
{
    // Neues Positionsobjekt
    oPos = new elemPos();

    // Wenn oElem ein Objekt ist    
	if (oElem)
	{
		// Schleife über alle Elternelemente
		while (oElem.offsetParent != null) 
		{
			oPos.left += oElem.offsetLeft;
			oPos.top += oElem.offsetTop;
			oElem = oElem.offsetParent;
		}
	}
	
	return oPos;
}

// PunktObjekt
function elemPos()
{
    this.left = 0;
    this.top = 0;
}

//***********************************************************************
// HANDLER zum Initialisieren, Zeichnen und Aufheben des Zoom-Rechtecks
//***********************************************************************

// Initialisieren des Rechtecks
function startTracking(x, y)
{
	isTracking = true;
	trackPosx = x
	trackPosy = y
	
	var style;
	
	if(ns6) 		
		style = document.getElementById("trackRectTop").style;	
	else
	    style = document.all["trackRectTop"].style;		
		
	style.left = trackPosx + "px";
	style.top = trackPosy + "px";
	style.visibility = 'visible'
	style.border = "solid 2px #ff0000";
	
	if(msie) {  //IE kann keine Höhe von 0 darstellen
	    style.width = "1px";
	    style.height = "1px";
	}
	else {
	    style.width = "0px";
	    style.height = "0px";
	}
}

// Zeichnen des Rechtecks beenden
function terminateTracking()
{
    var style;
    if(ns6)
	    style = document.getElementById("trackRectTop").style;
	else 
	    style = document.all["trackRectTop"].style;
	
	style.visibility = 'hidden';
	style.width = "1px";
    style.height = "1px";
    style.top = "1px";
    style.left = "1px";
}

// Recheck zeichnen
function drawTrackRect(x1, y1, x2, y2) {
	var trackRecttop, trackRectbottom, trackRectleft,trackRectright;

	if (x1 > x2)
	{
		trackRectleft = x2;
		trackRectright = x1;
	}
	else	
	{
		trackRectleft = x1;
		trackRectright = x2;				
	} 
	if (y1 > y2)
	{
		trackRecttop = y2;
		trackRectbottom = y1;
	}
	else	
	{
		trackRecttop = y1;
		trackRectbottom = y2;
	}
	
	var style;
	
    if (ns6) {	
		style = document.getElementById('trackRectTop').style;
	}
	else {	
		style = document.all['trackRectTop'].style;		
	}
	
	style.left = trackRectleft + "px";
	style.top = trackRecttop + "px";
	style.fontSize = "0pt";
	
	if(msie) {
	    style.width = trackRectright - trackRectleft == 0 ? "1px" : trackRectright - trackRectleft + "px";
	    style.height = trackRectbottom - trackRecttop == 0 ? "1px" : trackRectbottom - trackRecttop + "px";
	}
	else {
	    style.width = trackRectright - trackRectleft == 0 ? "0px" : trackRectright - trackRectleft + "px";
	    style.height = trackRectbottom - trackRecttop == 0 ? "0px" : trackRectbottom - trackRecttop + "px";
	}
}