OpenLayers.Control.MousePosition.prototype.formatOutput= 
function(lonLat) {
	var digits = parseInt(this.numDigits);
	var htmlUTM = "<b>UTM RER:</b> " + 
	    this.prefix +
	    lonLat.lon.toFixed(0) +
	    this.separator + 
	    lonLat.lat.toFixed(0) +
	    this.suffix;
    var src = new OpenLayers.Projection('EPSG:23032');
    var dest = new OpenLayers.Projection('WGS84');
	var point = new OpenLayers.Geometry.Point(lonLat.lon, lonLat.lat);	
    OpenLayers.Projection.transform(point, src, dest);
	var htmlWGS84 = "<b>WGS84:</b> " + 
	    this.prefix +
	    point.x.toFixed(digits) +
	    this.separator + 
	    point.y.toFixed(digits) +
	    this.suffix;
	var newHtml = htmlUTM + "&nbsp;&nbsp;" + htmlWGS84;
	return newHtml;
}

OpenLayers.Control.KeyboardDefaults.prototype.defaultKeyPress= 
function(evt) {
     switch(evt.keyCode) {
        // PAN KEYS (UP, DOWN, LEFT, RIGHT ARROWS / PAGE UP, PAGE DOWN, HOME, END)
        case OpenLayers.Event.KEY_LEFT:
            this.map.pan(-this.slideFactor, 0);
            break;
        case OpenLayers.Event.KEY_RIGHT: 
            this.map.pan(this.slideFactor, 0);
            break;
        case OpenLayers.Event.KEY_UP:
            this.map.pan(0, -this.slideFactor);
            break;
        case OpenLayers.Event.KEY_DOWN:
            this.map.pan(0, this.slideFactor);
            break;
        case 33: // Page Up  
            var size = this.map.getSize();
            this.map.pan(0, -0.75*size.h);
            break;
        case 34: // Page Down  
            var size = this.map.getSize();
            this.map.pan(0, 0.75*size.h);
            break; 
        case 35: // End  
            var size = this.map.getSize();
            this.map.pan(0.75*size.w, 0);
            break; 
        case 36: // Pos1  
            var size = this.map.getSize();
            this.map.pan(-0.75*size.w, 0);
            break; 

        // ZOOM KEYS (+, -, T, t)
        case 43: // + 
            this.map.zoomIn();
            break; 
        case 45: // - 
            this.map.zoomOut();
            break; 
        case 107: // + (IE only)
            this.map.zoomIn();
            break;
        case 109: // - (IE only)
            this.map.zoomOut();
            break;
        case 84: // T = Zoom Tutto
            //this.map.setCenter(new OpenLayers.LonLat(659000.00,921000.00),0);
            this.map.setCenter(new OpenLayers.LonLat(640440.00,926248.00),0);
            break;
        case 116: // t = Zoom Tutto
            //this.map.setCenter(new OpenLayers.LonLat(659000.00,921000.00),0);
            this.map.setCenter(new OpenLayers.LonLat(640440.00,926248.00),0);
            break;

        // TOGGLE ELEMENTS KEYS (O, o, S, s, L, l, N, n, R, r,C,c)
        case 79: // O = Overview
            overview.toggleChild();
            break;
        case 111: // o = Overview 
            overview.toggleChild();
            break;
        case 83: // S = Sidebar
            toggleSideBar();
            break;
        case 115: // s = Sidebar
            toggleSideBar();
            break;
        case 76: // L = Legenda            
            showLegendContents();
            break;            
        case 108: // l = Legenda
            showLegendContents();
            break;        
        case 82: // R = Risultati
            showResultsContents();            
            break;
        case 114: // r = Risultati
            showResultsContents();            
            break;
        case 80: // P = Ricerca percorso
        	reset_init('percorsi');
            break;
        case 112: // p = Ricerca percorso
        	reset_init('percorsi');
            break;
        case 73: // I = Ricerca itinerario
        	reset_init('itinerari');
            break;
        case 105: // i = Ricerca itinerario
        	reset_init('itinerari');
            break;
        case 67: // c oppure C = Cerca punti d'interesse
             reset_init('localita');
             break;    

        // SWITCH LAYER (1, 2, 3)
        case 49: // 1 = Mappa di base
            SwitchLayer(testoSwitcherMappaBase);
            break;
        case 50: // 2 = Satellite      	
            SwitchLayer(testoSwitcherOrtofoto);
            break; 
        case 51: // 3 = Altro
        	layerSwitcher.showOverlayDiv();
        	break;       
    }
}

OpenLayers.Control.Scale.prototype.updateScale= 
function(evt) {
    var scale = this.map.getScale();
    if (!scale) {
        return;
    }

    if (scale >= 9500 && scale <= 950000) {
        scale = Math.round(scale / 1000) + "000";
    } else if (scale >= 950000) {
        scale = Math.round(scale / 1000000) + "000000";
    } else {
        scale = Math.round(scale);
    }    
    
    this.element.innerHTML = scalaCorrente + "= 1:" + scaleArray[map.getZoom()]; //OpenLayers.i18n("scale", {'scaleDenom':scale});
}

MW.Control.Info.prototype.defaultMouseDown= 
function(evt) {
        if (this.info.CLASS_NAME == 'MW.Control.FloatingPanel.Info.GetFeatureInfo') {
            this.info.setMousePosition({x: evt.x, y: evt.y});
        }
        this.map.addControl(this.info);
}

MW.Control.FloatingPanel.Info.GetFeatureInfo.prototype.draw=
function() {
    	
       // MW.Contol.FloatingPanel.prototype.draw.apply(this, arguments);
        if (this.statusCode == "loading") {
            return;
        }
        if (this.div == null) {
            MW.Control.FloatingPanel.prototype.draw.apply(this, arguments);			
        }
        else {
        	if (this.childElement==null)
        	{
        		 MW.Control.FloatingPanel.prototype.draw.apply(this, arguments);
        	}
            this.childElement.innerHTML = "";
        }
        
        this.div.style.width = this.size.w;
        this.childElement.style.height = '';
        this.childElement.style.maxHeight = this.size.h + 'px';
        this.childElement.style.overflow = 'auto';
        var arVersion = navigator.appVersion.split("MSIE");
        var version = parseFloat(arVersion[1]);
        
	    this.divInfo = document.createElement('div');
	    this.divInfo.className = 'Info';
	    this.divInfo.id = 'Info';
	    this.childElement.appendChild(this.divInfo);  
            
        this.loadFeature();
        this.statusCode = "loading";
        
        this.div.style.display = 'none';    
        if (this.loading == null)      {
            this.loading = new MW.Control.LoadingMessage();
            
            if (this.loading != null) {
                if (language =='en')
                  this.loading.imgFileName ='loading_en.gif';
                this.map.addControl(this.loading);
            }
        }
        
        this.loading.startLoad();
        
        return this.div;
    }
    
MW.Control.FloatingPanel.Info.GetFeatureInfo.prototype.loadFeature= 
function() {
   	var px = new OpenLayers.Pixel(this.xy.x,this.xy.y);
   	var currentPosition = this.map.getLonLatFromPixel(px);
	  
  	var par = "?buffer=" + bufferArray[map.getZoom()] + "&locale=" +language+"&command=Info&pointGeom="+currentPosition.lon+","+currentPosition.lat+"&nomeProperties="+this.nomeProperties;
  	
	var visibleLayers = map.getLayersBy("inRange",true);
	
	par += "&layersList="
	for (var i=0;i<visibleLayers.length;i++)
	{
		if (visibleLayers[i].visibility==true && visibleLayers[i].params != undefined)
		{
                        if (visibleLayers[i].params.LAYERSNAMES)
                        {
                            par += visibleLayers[i].params.LAYERSNAMES;
                        }
                        else
                        {
                            if (visibleLayers[i].params.LAYERS)
                            {
                                    par += visibleLayers[i].params.LAYERS;
                            }
                            else
                            {
                                    var MWLayers = visibleLayers[i].layers;
                                    if (MWLayers != null)
                                    {
                                    	for (var j=0;j<MWLayers.length;j++)
	                                    {
                                            par += MWLayers[j].logicalName;
                                            if (j+1<MWLayers.length)
                                            {
                                                    par += ","; 
                                            }
	                                    }
                                    }
                                    
                            }
                        }
			if (i+1<visibleLayers.length)
			{
				par += ","; 
			}
		}
	}
	
    new OpenLayers.Ajax.Request(this.url + par,
                     {   method: 'post',
                         postBody: par,
		                 onComplete: this.successLoadFeature.bind(this),
		                 onFailure: this.errorLoadFeature.bind(this)
                      }
                     );
}
  
MW.Control.FloatingPanel.Info.GetFeatureInfo.prototype.successLoadFeature= 
function (response) {
        if ( (response.responseXML && response.responseXML.getElementsByTagName('ServiceException')[0] != null) 
            || this.statusCode == "loadFailure") {
            OpenLayers.Console.error('Error in response from server: ' + response.responseText);
            this.divInfo.innerHTML = "<b>Errore nella richiesta, contattare l'amministratore.<b>";
        }
        else if (response.responseText) {
        	var xml = this.stringClean(response.responseText);
        	xml = this.replaceSpecialChars(xml);
	        var html = MW.transformXml(xml,this.xsl);
			html=html.replace(/&lt;/g , "<");
			html=html.replace(/&gt;/g , ">");
			this.divInfo.innerHTML = html;			
        }  
        if (document.getElementById(this.childElement.id)==null) {
            this.div.appendChild(this.childElement);
            var imgReset = document.getElementById('sbImgNascondi' + this.idname);
            if(imgReset!=null) {
                // Substitute the image
                imgReset.src = OpenLayers.ImgPath + 'floating/nascondi.gif';
            }
        } 
        this.statusCode = "loadComplete";
        this.events.triggerEvent("loadComplete");
        this.div.style.display = 'block'; 
        this.div.style.height = this.size.h + 'px'; 
        var sizechild = this.size.h - 25;
        this.childElement.style.height = sizechild + 'px'; 
        this.loading.stopLoad();       
     };

MW.Control.FloatingPanel.Info.GetFeatureInfo.prototype.stringClean= 
function (string) {
    return string.replace(/\r|\n/g, '');
};

        
MW.Control.ZoomBar.prototype._addZoomBar = 
function(centered) {
    var imgLocation = OpenLayers.Util.getImagesLocation();

    // carico le icone modificate
   // imgLocation=imgLocation+'/toolbar/internal/';
    var id = "OpenLayers_Control_PanZoomBar_Slider" + this.map.id;
    var zoomsToEnd = this.map.getNumZoomLevels() - 1 - this.map.getZoom();
    var slider = OpenLayers.Util.createAlphaImageDiv(
        id,
       centered.add(-1, zoomsToEnd * this.zoomStopHeight),
       this.sliderSize,
       imgLocation+ this.imageLocation + this.sliderIcon,
       "absolute");
    this.slider = slider;

    this.sliderEvents = new OpenLayers.Events(this, slider, null, true,{includeXY: true});
    this.sliderEvents.register("mousedown", this, this.zoomBarDown);
    this.sliderEvents.register("mousemove", this, this.zoomBarDrag);
    this.sliderEvents.register("mouseup", this, this.zoomBarUp);
    this.sliderEvents.register("dblclick", this, this.doubleClick);
    this.sliderEvents.register("click", this, this.doubleClick);

    sz = new OpenLayers.Size();
    sz.h = this.zoomStopHeight * (this.map.getNumZoomLevels()+1);
    sz.w = this.zoomStopWidth;
    var div = null

    if (OpenLayers.Util.alphaHack()) {
        var id = "OpenLayers_Control_PanZoomBar" + this.map.id;
        div = OpenLayers.Util.createAlphaImageDiv(
            id, 
            centered,
            new OpenLayers.Size(sz.w,this.zoomStopHeight),
            imgLocation + this.zoombarIcon,
            "absolute", 
            null, 
            "crop");
        div.style.height = sz.h;
    } else {
        div = OpenLayers.Util.createDiv(
            'OpenLayers_Control_PanZoomBar_Zoombar' + this.map.id,
            centered,
            sz,
            imgLocation+ this.zoombarIcon);
    }

    this.zoombarDiv = div;

    this.divEvents = new OpenLayers.Events(this, div, null, true, {includeXY: true});
    this.divEvents.register("mousedown", this, this.divClick);
    this.divEvents.register("mousemove", this, this.passEventToSlider);
    this.divEvents.register("dblclick", this, this.doubleClick);
    this.divEvents.register("click", this, this.doubleClick);

    var arVersion = navigator.appVersion.indexOf("MSIE");
    if (arVersion != -1) {this.divEvents.register("mouseover", this, this.removeOffset);}

    this.div.appendChild(div);

    this.startTop = parseInt(div.style.top);
    this.div.appendChild(slider);

    this.map.events.register("zoomend", this, this.moveZoomBar);

    centered = centered.add(0,this.zoomStopHeight * this.map.getNumZoomLevels());
    return centered;
}

MW.Control.ZoomBar.prototype.draw = 
function(px){
    // initialize our internal div
    MW.Control.prototype.draw.apply(this, arguments);
    px = this.position.clone();
    // place the controls
    this.buttons = [];
        
    var szNS = new OpenLayers.Size(15,10);
    var szEO = new OpenLayers.Size(10,15);
    var szFull = new OpenLayers.Size(15,15);    
    var sz = new OpenLayers.Size(9,9);
    
    var centered = new OpenLayers.Pixel(px.x+20+sz.w/2, px.y+10+sz.w/2);
    this._addButton("ombra", "ombratutto.gif", centered.add(-8, 3), 0);
    this._addButton("panup", "north-mini.gif", centered.add(4, 12), szNS);
    this.buttons[1].firstChild.title=tipPanNorth
    px.y = centered.y+sz.h;
    this._addButton("panleft", "west-mini.gif", centered.add(-szEO.w+5, szEO.h+7), szEO);
    this.buttons[2].firstChild.title=tipPanWest
    this._addButton("zoomworld", "zoom-world-mini.gif", centered.add(4, szFull.h+7), szFull);
    this.buttons[3].firstChild.title=tipFullZoom
    this._addButton("panright", "east-mini.gif", centered.add(szEO.w+8, szEO.h+7), szEO);
    this.buttons[4].firstChild.title=tipPanEast
    this._addButton("pandown", "south-mini.gif", centered.add(4, szNS.h*2+17), szNS);
    this.buttons[5].firstChild.title=tipPanSouth
    
    var sz1 = new OpenLayers.Size(20,15);
    this._addButton("zoomin", "zoom-plus-mini.gif", centered.add(1, sz.h*3+26), sz1);
    this.buttons[6].firstChild.title=tipZoomIn
    centered = this._addZoomBar(centered.add(+1, sz.h*4 + 32));
    this._addButton("zoomout", "zoom-minus-mini.gif", centered.add(0, sz.h/2+3), sz1);
    this.buttons[7].firstChild.title=tipZoomOut
    return this.div; 
}

//Setta il valore per lo zoom al centro mappa
MW.Control.ZoomBar.prototype.buttonDown = function (evt) {
    if (!OpenLayers.Event.isLeftClick(evt)) return;
    switch (this.action) {
        case "panup": 
            this.map.pan(0, -50);
            break;
        case "pandown": 
            this.map.pan(0, 50);
            break;
        case "panleft": 
            this.map.pan(-50, 0);
            break;
        case "panright": 
            this.map.pan(50, 0);
            break;
        case "zoomin": 
            this.map.zoomIn(); 
            break;
        case "zoomout": 
            this.map.zoomOut(); 
            break;
        case "zoomworld": 
			//map.setCenter(new OpenLayers.LonLat(659000.00,921000.00),0);
            map.setCenter(new OpenLayers.LonLat(640440.00,926248.00),0);            
            break;
    }
    OpenLayers.Event.stop(evt);
}

/*
	Riscrittura del metodo per modificare lo stile del cursore durante un pan tramite mouse
*/
MW.Control.DragPan.prototype.panMap = function(xy) {

        document.getElementById("map").style.cursor = "url(img/mp/cursoreMano.cur),auto";
        this.panned = true;
        var deltaX = this.handler.last.x - xy.x;
        var deltaY = this.handler.last.y - xy.y;
        var size = this.map.getSize();
        var newXY = new OpenLayers.Pixel(size.w / 2 + deltaX,
                                         size.h / 2 + deltaY);
        var newCenter = this.map.getLonLatFromViewPortPx( newXY );
    	if (this.map.getLayerByName(this.map.layerMinZoomLevel) == null ||
    		this.map.getZoom() > 0)
    	{
	        this.map.setCenter(newCenter, null, this.handler.dragging);
    	}
    }
    
/**
	Riscriviamo il metodo per ripristinare lo stile del cursore dopo un pan fatto con il mouse
*/
MW.Control.DragPan.prototype.panMapDone = function(xy) {
        if(this.panned) {
            this.panMap(xy);
            this.panned = false;
        }
        document.getElementById("map").style.cursor = "crosshair";
    }
        

/*
	Un livello di zoom per essere valido deve ANCHE essere minore del minimo livello di zoom in cui un layer 
	pu� essere mostrato (solo nel caso in cui il parametro minZoomVisibleLevel � impostato per un dato layer
*/
MW.Map.prototype.isValidZoomLevel = function(zoomLevel) {	
	   var isValid = (zoomLevel != null) && (zoomLevel >= this.minZoomLevel) && (zoomLevel < this.getNumZoomLevels());
                
       if (this.baseLayer.minZoomVisibleLevel != null)
       {
       		if(zoomLevel!= null && zoomLevel < this.getNumZoomLevels())
       		{
       			isValid = isValid && (zoomLevel >= this.baseLayer.minZoomVisibleLevel );
       			if (!isValid)
	       			alert(zoomLevelInvalid);
	       	}
       }
                       
       return ( isValid  );
    }  

 
/**
	Modificato in modo da non registrare gli eventi click, mousedown e dblclick sul div del marker.
	Questo impediva di posizionare due tappe del'itinerario una sopra l'altra 
*/
MW.Marker.prototype.initialize = function(options) {
			        OpenLayers.Util.extend(this, options);
			        
			        if (this.iconSize == null)
			        {
					    this.iconSize = new OpenLayers.Size(35, 35);
			        }
    	
					var yOffset;
					if (this.position == "center")
					{
						yOffset = -this.iconSize.h/2;
					}
					else
					{
						yOffset = -this.iconSize.h;
					}
					if (this.iconUrl != null)
				       	{
						var offset = new OpenLayers.Pixel(-(this.iconSize.w/2), yOffset);
						this.icon = new OpenLayers.Icon(this.iconUrl,this.iconSize,offset);
				       	}
				       	else
				       	{
				       		if (this.icon==null)
				       		{
				       			//this.icon = OpenLayers.Marker.defaultIcon();
				       			var offset = new OpenLayers.Pixel(-(this.iconSize.w/2), yOffset);
				       			this.icon = new OpenLayers.Icon(OpenLayers.ImgPath + 'marker.png',this.iconSize,offset);
				       		}
				       	}
				    }				    				    

MW.Control.SimpleLayerSwitcher.prototype.redraw=
function() {
        //if the state hasn't changed since last redraw, no need 
        // to do anything. Just return the existing div.
        if (!this.checkRedraw()) { 
            return this.div; 
        } 

        //clear out previous layers 
        this.clearLayersArray();
        
        var containsBaseLayers = false;
        
        // Save state -- for checking layer if the map state changed.
        // We save this before redrawing, because in the process of redrawing
        // we will trigger more visibility changes, and we want to not redraw
        // and enter an infinite loop.
        this.layerStates = new Array(this.map.layers.length);
        for (var i = 0; i < this.map.layers.length; i++) {
            var layer = this.map.layers[i];
            this.layerStates[i] = {
                'name': layer.name, 
                'visibility': layer.visibility,
                'inRange': layer.inRange,
                'id': layer.id
            };
        }    

        var layers = this.map.layers.slice();
        if (!this.ascending) { layers.reverse(); }
	
        var j=0;
        for( var i = 0; i < layers.length; i++) {
            var layer = layers[i];
            var baseLayer = layer.isBaseLayer;

            if (layer.displayInLayerSwitcher && baseLayer) {
				j++;
				
                // only check a baselayer if it is *the* baselayer, check data
                //  layers if they are visible
                var checked = (baseLayer) ? (layer == this.map.baseLayer)
                                          : layer.getVisibility();
                                          
                var layerDiv = document.createElement("div");
				layerDiv.id = this.id + "_layerdiv_" + j;
                if (checked)
                {
                    layerDiv.className = "buttonClassSelected";
                }
                else
                {
                    layerDiv.className = "buttonClassUnselected";
                }
                
                var context = {
                    'inputElem': layerDiv,
                    'layer': layer,
                    'layerSwitcher': this
                }
                /*OpenLayers.Event.observe(layerDiv, "mouseup", 
                    OpenLayers.Function.bindAsEventListener(this.onInputClick,
                                                            context)
                );*/
                
                // create span
                var labelSpan = document.createElement("span");
                
                labelSpan.innerHTML = layer.name;
                
                OpenLayers.Event.observe(labelSpan, "click", 
                    OpenLayers.Function.bindAsEventListener(this.onInputClick,
                                                            context)
                );
                
                layerDiv.appendChild(labelSpan);
                
                this.div.appendChild(layerDiv);
            }
            else if (layer.displayInLayerSwitcher && !baseLayer)
            {
            	if (this.layerMoreDiv==null)
            	{
	                this.layerMoreDiv = document.createElement("div");
					this.layerMoreDiv.id = this.id + "_layermorediv";
	                this.layerMoreDiv.className = "buttonClassUnselected moreDivUnselected";
	                // create span
	                var labelSpan = document.createElement("span");
	                
	                labelSpan.innerHTML = this.titleMore;
	                
	                this.layerMoreDiv.appendChild(labelSpan);
	                
	                this.overlayDiv = document.createElement("div");
					this.overlayDiv.id = this.id + "_overlaydiv";
	                this.overlayDiv.className = "overlayDiv hidden";
	                
	                var context = {
	                	'layerMoreDiv': this.layerMoreDiv,
	                    'overlayDiv': this.overlayDiv,
	                	'layerSwitcher': this
	                }
	                OpenLayers.Event.observe(this.layerMoreDiv, "mouseover", OpenLayers.Function.bindAsEventListener(this.showOverlayDivEvent,
                                                            context));
                    OpenLayers.Event.observe(this.layerMoreDiv, "mouseout", OpenLayers.Function.bindAsEventListener(this.hideOverlayDiv,
                                                            context));
					OpenLayers.Event.observe(this.overlayDiv, "mouseover", OpenLayers.Function.bindAsEventListener(this.showOverlayDivEvent,
                                                            context));
					OpenLayers.Event.observe(this.overlayDiv, "mouseout", OpenLayers.Function.bindAsEventListener(this.hideOverlayDiv,
                                                            context));
            	}
                this.div.appendChild(this.layerMoreDiv);
                this.div.appendChild(this.overlayDiv);

                var rowDiv = document.createElement("div");
                //this.overlayDiv.className = "overlayDiv hidden";
                this.overlayDiv.appendChild(rowDiv);
                
                // create input element
                var inputElem = document.createElement("input");
                inputElem.id = "input_" + layer.name + "_" + i;
                inputElem.name = layer.name;
                inputElem.type = "checkbox";
                inputElem.value = layer.name;
                var checked = layer.calculateInRange() && layer.getVisibility();
                var enabled = layer.calculateInRange();
                if (!enabled)
                {
	                inputElem.disabled = "disabled";
                }
                else
                {
	                inputElem.disabled = "";
                }
                inputElem.checked = checked;
                inputElem.defaultChecked = checked;
                
                var context = {
                    'overlay': layer,
                	'inputElem': inputElem,
                	'layerSwitcher': this
                }
                OpenLayers.Event.observe(inputElem, "mouseup", OpenLayers.Function.bindAsEventListener(this.onInputOverlayClick,
                                                            context));

                OpenLayers.Event.observe(inputElem, "keyup", OpenLayers.Function.bindAsEventListener(this.onInputOverlayKeyPress,
                                                            context));
                                                            
                rowDiv.appendChild(inputElem);
                
                var labelSpan = document.createElement("span");
                labelSpan.innerHTML = layer.name;
                rowDiv.appendChild(labelSpan);
                
                OpenLayers.Event.observe(labelSpan, "mouseup", OpenLayers.Function.bindAsEventListener(this.onInputOverlayClick,
                                                            context));
                                                    
                if (this.overlayDivOpened)
                {
			    	this.showOverlayDiv();
                }
            }
        }

        return this.div;
    }
    
    
MW.Control.SimpleLayerSwitcher.prototype.onInputClick=
function(e) {
    if (this.layer.minZoomVisibleLevel != null )
    {
        if (this.layer.minZoomVisibleLevel > this.layer.map.zoom)
        {                        
            OpenLayers.Event.stop(e);
            alert(mapNotVisible);		       	    
            return; 
        }
    }
		
    //Set button as selected
    this.layer.map.setBaseLayer(this.layer);
    if(this.layer.backgroundColor != null){
            this.layer.map.viewPortDiv.style.backgroundColor = this.layer.backgroundColor;
    }else{
            this.layer.map.viewPortDiv.style.backgroundColor = null;
    }
		
    if (this.layerSwitcher.overlay && this.layerSwitcher.overlay.length > 0)
    {
        for(var i = 0;i<this.layerSwitcher.overlay.length;i++){
            this.layerSwitcher.overlay[i].setVisibility(false);
        }
    }
    if (this.layer.overlay && this.layer.overlay.length > 0)
    {
        for(var i = 0;i<this.layerSwitcher.overlay.length;i++){
            if(this.layer.overlay[i]){
                this.layerSwitcher.overlay[i] = this.layer.map.getLayerByName(this.layer.overlay[i]);
                this.layerSwitcher.overlay[i].setVisibility(true);
            }
        }
    }
        OpenLayers.Event.stop(e);
}