var mapBounds = new GLatLngBounds(new GLatLng(47.6243648843, 16.6208314318), new GLatLng(49.7395972673, 22.6524353917));
			    var mapMinZoom = 5;
			    var mapMaxZoom = 12;

			    var opacity = 0.55;
			    var map;
			    var ge;
				var MUX = 'MUX1/';
			  //  var hybridOverlay;
			  
			   function readMUX(rad) 
				{ 
				
					MUX = rad.value;
					map.removeOverlay(overlay);
					this.addPokrytie();
				}
				
				function addPokrytie(){
					
			          var tilelayer = new GTileLayer(GCopyrightCollection("a.png"), mapMinZoom, mapMaxZoom);
			          var mercator = new GMercatorProjection(mapMaxZoom+1);
			          tilelayer.getTileUrl = function(tile,zoom) {
			              if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {
			                  return "mapy/none.png";
			              } 
			              var ymax = 1 << zoom;
			              var y = ymax - tile.y -1;
			              var tileBounds = new GLatLngBounds(
			                  mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),
			                  mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )
			              );
			              if (mapBounds.intersects(tileBounds)) {
			                  return "mapy/"+MUX+zoom+"/"+tile.x+"/"+y+".png";
			              } else {
			                  return "mapy/none.png";
			              }
			          }
			          tilelayer.isPng = function() { return true;};
			          tilelayer.getOpacity = function() { return opacity; }

			          overlay = new GTileLayerOverlay( tilelayer );
			          map.addOverlay(overlay);
				} 

			    /*
			     * Create a Custom Opacity GControl
			     * http://www.maptiler.org/google-maps-overlay-opacity-control/
			     */

			    var CTransparencyLENGTH = 58; 
			    // maximum width that the knob can move (slide width minus knob width)

			    function CTransparencyControl( overlay ) {
			        this.overlay = overlay;
			        this.opacity = overlay.getTileLayer().getOpacity();
			    }
			    CTransparencyControl.prototype = new GControl();

			    // This function positions the slider to match the specified opacity
			    CTransparencyControl.prototype.setSlider = function(pos) {
			        var left = Math.round((CTransparencyLENGTH*pos));
			        this.slide.left = left;
			        this.knob.style.left = left+"px";
			        this.knob.style.top = "0px";
			    }

			    // This function reads the slider and sets the overlay opacity level
			    CTransparencyControl.prototype.setOpacity = function() {
				    // set the global variable
			        opacity = this.slide.left/CTransparencyLENGTH;
			        this.map.clearOverlays();
			        this.map.addOverlay(this.overlay, { zPriority: 0 });
			        if (this.map.getCurrentMapType() == G_HYBRID_MAP) {
			            this.map.addOverlay(hybridOverlay);
			        }
			    }

			    // This gets called by the API when addControl(new CTransparencyControl())
			    CTransparencyControl.prototype.initialize = function(map) {
			        var that=this;
			        this.map = map;

			        // Is this MSIE, if so we need to use AlphaImageLoader
			        var agent = navigator.userAgent.toLowerCase();
			        if ((agent.indexOf("msie") > -1) && (agent.indexOf("opera") < 1)){this.ie = true} else {this.ie = false}

			        // create the background graphic as a <div> containing an image
			        var container = document.createElement("div");
			        container.style.width="70px";
			        container.style.height="21px";

			        // Handle transparent PNG files in MSIE
			        if (this.ie) {
			          var loader = "filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');";
			          container.innerHTML = '<div style="height:21px; width:70px; ' +loader+ '" ></div>';
			        } else {
			          container.innerHTML = '<div style="height:21px; width:70px; background-image: url(http://www.maptiler.org/img/opacity-slider.png)" ></div>';
			        }

			        // create the knob as a GDraggableObject
			        // Handle transparent PNG files in MSIE
			        if (this.ie) {
			          var loader = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');";
			          this.knob = document.createElement("div"); 
			          this.knob.style.height="21px";
			          this.knob.style.width="13px";
				  this.knob.style.overflow="hidden";
			          this.knob_img = document.createElement("div"); 
			          this.knob_img.style.height="21px";
			          this.knob_img.style.width="83px";
			          this.knob_img.style.filter=loader;
				  this.knob_img.style.position="relative";
				  this.knob_img.style.left="-70px";
			          this.knob.appendChild(this.knob_img);
			        } else {
			          this.knob = document.createElement("div"); 
			          this.knob.style.height="21px";
			          this.knob.style.width="13px";
			          this.knob.style.backgroundImage="url(http://www.maptiler.org/img/opacity-slider.png)";
			          this.knob.style.backgroundPosition="-70px 0px";
			        }
			        container.appendChild(this.knob);
			        this.slide=new GDraggableObject(this.knob, {container:container});
			        this.slide.setDraggableCursor('pointer');
			        this.slide.setDraggingCursor('pointer');
			        this.container = container;

			        // attach the control to the map
			        map.getContainer().appendChild(container);

			        // init slider
			        this.setSlider(this.opacity);

			        // Listen for the slider being moved and set the opacity
			        GEvent.addListener(this.slide, "dragend", function() {that.setOpacity()});
			        //GEvent.addListener(this.container, "click", function( x, y ) { alert(x, y) });

			        return container;
			      }

			      // Set the default position for the control
			      CTransparencyControl.prototype.getDefaultPosition = function() {
			        return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 32));
			      }

			    /*
			     * Full-screen Window Resize
			     */

	/*		    function getWindowHeight() {
			        if (self.innerHeight) return self.innerHeight;
			        if (document.documentElement && document.documentElement.clientHeight)
			            return document.documentElement.clientHeight;
			        if (document.body) return document.body.clientHeight;
			        return 0;
			    }

			    function getWindowWidth() {
			        if (self.innerWidth) return self.innerWidth;
			        if (document.documentElement && document.documentElement.clientWidth)
			            return document.documentElement.clientWidth;
			        if (document.body) return document.body.clientWidth;
			        return 0;
			    }
*/
function LegatoLogoControl() {}

LegatoLogoControl.prototype = new GControl();

LegatoLogoControl.prototype.initialize = function(map)
{
     var container = document.createElement("div");

     var lnk = document.createElement("a");
  //   lnk.href = 'http://www.legato.sk';
  //   lnk.title = 'Historic map';
     lnk.target = '_blank';

     var img = document.createElement("img");
     img.src = 'mapy/legatoLogo.png';

     lnk.appendChild(img);
     container.appendChild(lnk);
     map.getContainer().appendChild(container);

     return container;
}


LegatoLogoControl.prototype.getDefaultPosition = function()
{
     return new GControlPosition(G_ANCHOR_BOTTOM_LEFT, new GSize(75,5));
}










			    /*
			     * Main load function:
			     */

			    function load() {

			       if (GBrowserIsCompatible()) {

			          // Bug in the Google Maps: Copyright for Overlay is not correctly displayed
			          var gcr = GMapType.prototype.getCopyrights;
			          GMapType.prototype.getCopyrights = function(bounds,zoom) {
			              return ["&copy;"].concat(gcr.call(this,bounds,zoom));
			          }

			          map = new GMap2( document.getElementById("map"), { backgroundColor: '#fff' } );
//mapa terenu
			    /*      map.addMapType(G_PHYSICAL_MAP);
			          map.setMapType(G_PHYSICAL_MAP);
*/
			          map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));

			          hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );
			          GEvent.addListener(map, "maptypechanged", function() {
			            if (map.getCurrentMapType() == G_HYBRID_MAP) {
			                map.addOverlay(hybridOverlay);
			            } else {
			               map.removeOverlay(hybridOverlay);
			            }
			          } );
G_NORMAL_MAP.getMinimumResolution = function () { return 5 }; 
G_SATELLITE_MAP.getMinimumResolution = function () { return 5 };
G_HYBRID_MAP.getMinimumResolution = function () { return 5 }; 
G_NORMAL_MAP.getMaximumResolution = function () { return 12 }; 
 G_SATELLITE_MAP.getMaximumResolution = function () { return 12 };
G_HYBRID_MAP.getMaximumResolution = function () { return 12 }; 
			          var tilelayer = new GTileLayer(GCopyrightCollection("a.png"), mapMinZoom, mapMaxZoom);
			          var mercator = new GMercatorProjection(mapMaxZoom+1);
			          tilelayer.getTileUrl = function(tile,zoom) {
			              if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {
			                  return "mapy/none.png";
			              } 
			              var ymax = 1 << zoom;
			              var y = ymax - tile.y -1;
			              var tileBounds = new GLatLngBounds(
			                  mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),
			                  mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )
			              );
			              if (mapBounds.intersects(tileBounds)) {
			                  return "mapy/"+MUX+zoom+"/"+tile.x+"/"+y+".png";
			              } else {
			                  return "mapy/none.png";
			              }
			          }
			          // IE 7-: support for PNG alpha channel
			          // Unfortunately, the opacity for whole overlay is then not changeable, either or...
			          tilelayer.isPng = function() { return true;};
			          tilelayer.getOpacity = function() { return opacity; }

			          overlay = new GTileLayerOverlay( tilelayer );
			          map.addOverlay(overlay);

			          map.addControl(new GLargeMapControl3D());
			          map.addControl(new GHierarchicalMapTypeControl());
			          map.addControl(new CTransparencyControl( overlay ));
			  
					map.addControl(new LegatoLogoControl());
		

			          map.enableContinuousZoom();
			          map.enableScrollWheelZoom();

			          map.setMapType(G_NORMAL_MAP);
			       }
			     //  document.write("<b>Tento prehliadac nie je kompatibylny s google maps</b>");
		/*	else{	 
				alert("Tento prehliadac nie je kompatibylny s google maps");
				}*/
			    }
		
	//		    onresize=function(){ resize(); };