Ticket #442: final_animatedZooming_Core.patch

tests/test_Util.html

@@ -563 +563 @@
-        
- 
-    }
-
+16_
-        t.plan(1);
-        OpenLayers.Util.lastSeqID = 0;
-        OpenLayers.Util.createDiv();
-        OpenLayers.Util.createDiv();
-        t.eq(OpenLayers.Util.createDiv().id, "OpenLayersDiv3", "Div created is sequential, starting at lastSeqID in Util.");
-    }
+
+
+
+    function test_18_Util_easeInOutZoom(t) {
+        t.plan(1);
+
+        var delta = 5; 
+        var totalSteps = 4;
+        var step = 1;
+        var power = 1;
+        var value = OpenLayers.Util.easeInOutZoom(delta,totalSteps,step,power);
+        t.eq( value, 1.25, "calculation correct");
+    }
+
-   // -->
-  </script>
-</head>

tests/test_Map.html

@@ -69 +69 @@
-        t.eq( map.theme, 'foo', "map theme set correctly." );
-    }
-    function test_05_Map_center(t) {
-4
+6
-        map = new OpenLayers.Map('map');
-        var baseLayer = new OpenLayers.Layer.WMS("Test Layer", 
-            "http://octo.metacarta.com/cgi-bin/mapserv?",
@@ -78 +78 @@
-        var ll = new OpenLayers.LonLat(2,1);
-        map.setCenter(ll, 0);
-        map.zoomIn();
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-    }
-
-    function test_06_Map_zoomend_event (t) {
@@ -108 +120 @@
-            });
-        map.setCenter(new OpenLayers.LonLat(2, 1), 0);
-        map.zoomIn();
-
+
+
+
+
+
+
+
-    }
-    
-    function test_07_Map_add_remove_popup (t) {

tests/Control/test_Permalink.html

@@ -17 +17 @@
-        map = new OpenLayers.Map('map');
-        layer = new OpenLayers.Layer.WMS('Test Layer', "http://octo.metacarta.com/cgi-bin/mapserv", {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'});
-        map.addLayer(layer);
-zoomToMaxExtent(
+setCenter(0,0
-        map.addControl(control);
-        map.pan(5, 0);
-        if (/MSIE/.test(navigator.userAgent)) {
-1.75781&zoom=2
+7.03125&zoom=0
-        } else {
-1.75781&zoom=2
+7.03125&zoom=0
-        }
-    }
-    function test_03_Control_Permalink_updateLinksBase (t) {
@@ -37 +37 @@
-        if (!map.getCenter())  map.zoomToMaxExtent();
-        map.addControl(control);
-        map.pan(5, 0);
-
-
+
+
+
+
-  }
-  function test_04_Control_Permalink_noElement (t) {
-        t.plan( 2 );

tests/Control/test_PanZoom.html

@@ -54 +54 @@
-        t.ok( map.getCenter().lat == centerLL.lat, "Pan down works correctly" );
-
-        control.buttons[4].onmousedown(evt);
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-        control.buttons[6].onmousedown(evt);
-        t.eq( map.getZoom(), 5, "zoomout works correctly" );
-
-        control.buttons[5].onmousedown(evt);
-        t.eq( map.getZoom(), 2, "zoomworld works correctly" );
-
-    }
-  // -->
-  </script>

tests/Control/test_Scale.html

@@ -18 +18 @@
-        layer = new OpenLayers.Layer.WMS('Test Layer', "http://octo.metacarta.com/cgi-bin/mapserv", {map: '/mapdata/vmap_wms.map', layers: 'basic', format: 'image/jpeg'});
-        map.addLayer(layer);
-        map.zoomTo(0);
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-    function test_03_Control_Scale_internalScale (t) {
-        t.plan(2);

tests/test_Marker.html

@@ -3 +3 @@
-  <script src="../lib/OpenLayers.js"></script>
-  <script type="text/javascript"><!--
-    var marker; 
-
+
+
-    function test_01_Marker_constructor (t) {
-        t.plan( 4 );
-        var ll = new OpenLayers.LonLat(2,1);
@@ -28 +29 @@
-        map.addLayer(mlayer);
-               
-        map.zoomToExtent(new OpenLayers.Bounds(-50,-50,50,50));
+        t.delay_call( 1, function() {
+            //onscreen marker
+            var ll = new OpenLayers.LonLat(0,0);
+            var marker = new OpenLayers.Marker(ll);
+            mlayer.addMarker(marker);
+            
+            t.ok( marker.onScreen(), "marker knows it's onscreen" );
-
-
-
-
-
-
-
+
+
+
+
-
-
-
-
-
-
-
-
+
+
-    }
-
-    function test_03_Marker_setOpacity(t) {
@@ -70 +71 @@
-        marker.setOpacity(0.5);
-
-        t.eq(parseFloat(marker.icon.imageDiv.style.opacity), 0.5, "marker.setOpacity() works");
-        map.destroy();
-    }
-    function test_04_Marker_moveTo(t) {
-        t.plan( 6 );
@@ -102 +102 @@
-        marker.moveTo(new OpenLayers.Pixel(0,0));
-        t.eq(marker.lonlat.lon, map.getExtent().left, "on left edge of map"); 
-        t.eq(marker.lonlat.lat, map.getExtent().top, "on top edge of map"); 
-        map.destroy();
-    
-    }
-
-  // -->

tests/test_Feature.html

@@ -92 +92 @@
-        
-        map.zoomToExtent(new OpenLayers.Bounds(-50,-50,50,50));
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-    }
-
-  // -->

tests/Layer/test_Grid.html

@@ -3 +3 @@
-  <script src="../../lib/OpenLayers.js"></script>
-  <script type="text/javascript"><!--
-    var isMozilla = (navigator.userAgent.indexOf("compatible") == -1);
+    var map;
-    var layer; 
-
-    var name = 'Test Layer';
@@ -32 +33 @@
-
-    function test_02_Layer_Grid_inittiles (t) {
-        t.plan( 2 );
-var 
+
-        layer = new OpenLayers.Layer.WMS(name, url, params);
-        map.addLayer(layer);
-        map.setCenter(new OpenLayers.LonLat(0,0),5);
@@ -43 +44 @@
-
-    function test_03_Layer_Grid_clearTiles (t) {
-        t.plan(1);
-var 
+
-        layer = new OpenLayers.Layer.WMS(name, url, params);
-        map.addLayer(layer);
-
@@ -81 +82 @@
-    function test_05_Layer_Grid_getResolution(t) {
-        t.plan( 1 );
-
-var 
+
-        layer = new OpenLayers.Layer.WMS(name, url, params);
-        map.addLayer(layer);
-
@@ -94 +95 @@
-        t.plan( 2 );
-        var bounds, zoom;
-
-var 
+
-        layer = new OpenLayers.Layer.WMS(name, url, params);
-        map.addLayer(layer);
-
@@ -132 +133 @@
-        t.plan(5);
-        
-        var options = {tileSize: new OpenLayers.Size(500,50)};
-var 
+
-        layer = new OpenLayers.Layer.Grid(name, url, params);
-        map.addLayer(layer);
-
@@ -156 +157 @@
-    }
-
-    function test_11_Layer_Grid_setMap(t) {
-
-        t.plan(2);
-        
-        var options = {tileSize: new OpenLayers.Size(500,50)};
-var 
+
-        layer = new OpenLayers.Layer.Grid(name, url, params);
-
-
@@ -171 +171 @@
-    }
-
-
+
+    /*** animated zooming test functions ***/
+
+    function test_12_Layer_Grid_setZoomOutTile (t) {
+        t.plan(5);
+        
+        map = new OpenLayers.Map('map');
+        layer = new OpenLayers.Layer.WMS(name, url, params);
+        map.addLayer(layer);
+        map.tileSize = new OpenLayers.Size(256,256); 
+        map.zoomOutTileFactor = 4;
+        var tile = map.baseLayer.zoomOutTile;
+
+        t.ok( tile instanceof OpenLayers.Tile.Image, 
+                "zoomOutTile is a Tile.Image object");
+        
+        var firstChild = map.baseLayer.div.firstChild;
+        t.eq( tile.imgDiv.id, firstChild.id, 
+                "zoomOutTile is first child of baseLayerDiv");
+
+        size = map.baseLayer.zoomOutTile.size;
+        t.eq( size.w, 1024, "zoomOutTile width is 1024px");
+        t.eq( size.h, 1024, "zoomOutTile height is 1024px");
+
+        t.ok( tile.imgDiv.style.display == "none", 
+                "zoomOutTile is invisible");
+    }
+
+
+    function test_13_Layer_Grid_getTileSize (t) {
+        t.plan(2);
+
+        map = new OpenLayers.Map('map');
+        layer = new OpenLayers.Layer.WMS(name, url, params);
+        map.addLayer(layer);
+        map.tileSize = new OpenLayers.Size(256,256);  
+
+        size = map.baseLayer.getTileSize();
+        t.eq(size.w, 256, "tile width is correct"); 
+        t.eq(size.h, 256, "tile height is correct");
+    }
+
+    function test_14_Layer_Grid_getCenterTile (t) {
+        t.plan(1);
+
+        map = new OpenLayers.Map('map');
+        layer = new OpenLayers.Layer.WMS(name, url, params);
+        map.addLayer(layer);
+        map.setCenter(new OpenLayers.LonLat(0,0));
+        
+        tile = map.baseLayer.getCenterTile(); 
+        t.ok(tile.bounds.contains(0,0,true), 
+                "center tile has been set correctly" );
+    }
+
+    function test_15_Layer_Grid_setTilesOutsideInvisible (t) {
+        t.plan(1);
+
+        map = new OpenLayers.Map('map');
+        layer = new OpenLayers.Layer.WMS(name, url, params);
+        map.addLayer(layer);
+        map.setCenter(new OpenLayers.LonLat(0,0));
+        map.zoomTo(5,false);
+        map.baseLayer.setTilesOutsideInvisible();
+
+        var tileOutside = map.baseLayer.grid[0][0];
+        t.ok( tileOutside.imgDiv.style.display == "none", 
+                "tiles outside the viewport have been set invisible");
+
+    }
+
+    function test_16_Layer_Grid_scaleTilesOfGrid (t) {
+        t.plan(4);
+
+        map = new OpenLayers.Map('map');
+        layer = new OpenLayers.Layer.WMS(name, url, params);
+        map.addLayer(layer);
+        map.setCenter(new OpenLayers.LonLat(0,0));
+        map.zoomTo(5,false);
+        
+        var tile = map.baseLayer.grid[3][2];
+        var centerTile = map.baseLayer.getCenterTile();
+        var newTileSize = new OpenLayers.Size(128,128);
+        map.baseLayer.scaleTileTo(centerTile,newTileSize);
+        map.baseLayer.scaleTilesOfGrid(centerTile,newTileSize);
+
+        t.eq( tile.imgDiv.style.width, "128px", 
+                "width of tiles has been set correctly");
+        t.eq( tile.imgDiv.style.height, "128px", 
+                "height of tiles has been set correctly");
+        t.eq( tile.imgDiv.style.top, "147px", 
+                "top position of tiles has been set correctly");
+        t.eq( tile.imgDiv.style.left, "122px", 
+                "left position of tiles has been set correctly");
+    }
+
+    function test_17_Layer_Grid_scaleZoomOutTile (t) {
+        t.plan(5);
+
+        map = new OpenLayers.Map('map');
+        layer = new OpenLayers.Layer.WMS(name, url, params);
+        map.addLayer(layer);
+        map.setCenter(new OpenLayers.LonLat(0,0));
+        map.tileSize = new OpenLayers.Size(256,256);
+        map.zoomToMaxExtent();
+        var tile = map.baseLayer.zoomOutTile;
+        layer.firstCall = false; //set flag manually
+        map.baseLayer.scaleZoomOutTile(1,map.maxResolution/2);
+
+        t.eq( tile.imgDiv.style.width, "512px", 
+                "width of zoomOutTile has been set correctly");
+        t.eq( tile.imgDiv.style.height, "512px", 
+                "height of zoomOutTile has been set correctly");
+        t.eq( tile.imgDiv.style.top, "-109px", 
+                "top position of zoomOutTile has been set correctly");
+        t.eq( tile.imgDiv.style.left, "-6px", 
+                "left position of zoomOutTile has been set correctly");
+        t.ok( tile.imgDiv.style.display != "none", 
+                "zoomOutTile has been set visible");
+    }
+
+    function test_18_Layer_Grid_cloneBaseLayerDiv (t) {
+        t.plan(4);       
+
+        map = new OpenLayers.Map('map');
+        layer = new OpenLayers.Layer.WMS(name, url, params);
+        map.addLayer(layer);
+        
+        map.baseLayer.cloneBaseLayerDiv();
+        var cloneDiv = map.baseLayerDivClone;
+        var originDiv = map.baseLayer.div; 
+        t.ok( cloneDiv instanceof HTMLDivElement, 
+                "cloned baseLayerDiv is a valid HTMLDivElement");
+        t.eq( cloneDiv.childNodes.length, originDiv.childNodes.length,
+                "cloned baseLayerDiv has the same number of childs");
+        t.eq( parseInt(cloneDiv.style.zIndex)+1, parseInt(originDiv.style.zIndex),
+                "zIndex has been set correctly");
+        t.ok( map.baseLayer.zoomOutTile.imgDiv.style.display == "none",
+                "zoomOutTile of original div has been set invisible");
+    }
+
+
+
-    function test_99_Layer_Grid_destroy (t) {
-
-        t.plan( 5 );
-
-var 
+
-        layer = new OpenLayers.Layer.Grid(name, url, params);
-        map.addLayer(layer);
-        layer.destroy();
@@ -183 +326 @@
-        t.eq( layer.tileSize, null, "layer.tileSize is null after destroy" );
-
-
-
+    
-        layer = new OpenLayers.Layer.WMS(name, url, params);
-        map.addLayer(layer);
-

tests/Layer/test_MapServer.html

@@ -56 +56 @@
-             "image src is created correctly via addtile" );
-        t.eq( tile.imgDiv.style.top, "6px", "image top is set correctly via addtile" );
-        t.eq( tile.imgDiv.style.left, "5px", "image top is set correctly via addtile" );
+        
+        // get the 2nd child, because the 1st is a bigger zoomOutTile
+        var firstChild = layer.div.firstChild.nextSibling;
-
-        var firstChild = layer.div.firstChild;
-        if (!isMozilla)
-            t.ok( true, "skipping element test outside of Mozilla");
-        else

tests/Layer/test_WMS.html

@@ -26 +26 @@
-
-    }
-    
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        t.plan( 6 );
-    
-        var url = "http://octo.metacarta.com/cgi-bin/mapserv";
@@ -53 +75 @@
-        t.eq( tile.imgDiv.style.top, "6px", "image top is set correctly via addtile" );
-        t.eq( tile.imgDiv.style.left, "5px", "image top is set correctly via addtile" );
-
-
+
+
-        if (!isMozilla)
-            t.ok( true, "skipping element test outside of Mozilla");
-        else
@@ -65 +88 @@
-        map.destroy();
-    }
-    
-3
+4
-        t.plan( 2 );
-        var map = new OpenLayers.Map('map');
-        layer = new OpenLayers.Layer.WMS(name, url, params);
@@ -77 +100 @@
-    }
-
-
-4
+5
-        t.plan(4);
-        
-        var url = "http://octo.metacarta.com/cgi-bin/mapserv";
@@ -105 +128 @@
-        map.destroy();
-    }
-
-5
+6
-        t.plan(3);
-        
-        var url = "http://octo.metacarta.com/cgi-bin/mapserv";
@@ -121 +144 @@
-        t.ok( !layer.isBaseLayer, "baselayer is false when option is set to false" );
-    }
-
-6
+7
-        t.plan( 5 );
-
-        var map = new OpenLayers.Map("map");
@@ -147 +170 @@
-        map.destroy();
-    }
-
-7
+8
-
-        
-        t.plan( 2 );
@@ -178 +201 @@
- 
-    }
-
-8
+9
-        t.plan( 5 );
-
-        var map = new OpenLayers.Map('map');

lib/OpenLayers/Layer.js

@@ -107 +107 @@
-    /** @type Boolean */
-    displayOutsideMaxExtent: false,
-    
-
+
+
+
+
+
+
+
+
-    /**
-     * @constructor
-     * 
@@ -133 +140 @@
-        }
-
-        this.events = new OpenLayers.Events(this, this.div, this.EVENT_TYPES);
+        this.events.register("loadend", this, this.setLoadendVisibility);
-    },
-    
-    /**
@@ -465 +473 @@
-     */
-    getResolution: function() {
-        var zoom = this.map.getZoom();
+        if (zoom >= this.map.getNumZoomLevels())
+            zoom = this.map.getNumZoomLevels() - 1;
-        return this.resolutions[zoom];
-    },
-
@@ -546 +556 @@
-     *          translated into view port pixels
-     * @type OpenLayers.Pixel
-     */
-
+, resolution
-        var px = null; 
-        if (lonlat != null) {
-
+
+
-            var extent = this.map.getExtent();
-            px = new OpenLayers.Pixel(
-                           Math.round(1/resolution * (lonlat.lon - extent.left)),
@@ -580 +591 @@
-        this.div.style.zIndex = zIdx;
-    },
-
+
+
+
+    /********************************************************/
+    /*                                                      */
+    /*       Baselayer Functions for zooming/scaling        */
+    /*                                                      */
+    /********************************************************/
+
+    /** 
+     * Initializes zoomOut tile and sets a x-times bigger tile size.
+     *
+     * Default function; will override in subclasses,
+     * otherwise it returns false
+     * 
+     * @returns false if no zoomOutTile is set
+     * @type Boolean
+     */
+    setZoomOutTile:function() {
+        return false;
+    },
+
+    /**
+     * Initializes zoomOut tile and sets a x-times bigger tile size.
+     * 
+     * special function; shares with some baselayers; calls from subclasses
+     *
+     */
+    setZoomOutTile_share:function() {
+        if (!this.zoomOutTile) {
+            var bounds = this.map.getMaxExtent();
+            var resolution = this.resolutions[0]; 
+
+            // calculate tile bounds
+            var n = 0;
+            do {
+                resolution = resolution * Math.pow(2, n);
+                
+                var tilelon = resolution * this.map.tileSize.w;
+                var tilelat = resolution * this.map.tileSize.h;
+            
+                var tileoffsetlon = bounds.left;
+                var tileoffsetlat = bounds.bottom;
+                
+                var tileBounds = new OpenLayers.Bounds(tileoffsetlon, 
+                                                       tileoffsetlat, 
+                                                       tileoffsetlon + tilelon,
+                                                       tileoffsetlat + tilelat);
+                n++;
+            }
+            while (!tileBounds.containsBounds(bounds, false, true));
+
+            var tileSize = new OpenLayers.Size();
+            tileSize.w = this.map.zoomOutTileSizeFactor * this.map.tileSize.w;
+            tileSize.h = this.map.zoomOutTileSizeFactor * this.map.tileSize.h;
+
+            // formulate request url string
+            var url = this.getURL(tileBounds, tileSize); 
+            // default start position
+            var pos = new OpenLayers.Pixel (0,0); 
+            // default start size
+            var tilesize = new OpenLayers.Size(0,0);
+
+            this.zoomOutTile = new OpenLayers.Tile.Image(this, pos, tileBounds, 
+                                                        url, tileSize);
+
+            // draw tile -> sets imgDiv
+            this.zoomOutTile.draw();
+
+            // resize zoomOutTile
+            this.zoomOutTile.imgDiv.style.width = 0;
+            this.zoomOutTile.imgDiv.style.height = 0;
+            
+            // set zoomOut tile invisible 
+            if (this.map.baseLayer.zoomOutTile)
+                this.map.baseLayer.zoomOutTile.imgDiv.style.display = "none";
+        }
+    },
+ 
+    /** 
+     * Gets the current tile size of the layer.
+     *
+     * Default function; will override in subclasses,
+     * otherwise it returns false - that means: no scaling possible!
+     * 
+     * @returns null if no tile size set
+     * @type OpenLayers.Size
+     */
+    getTileSize:function() {
+        return null;
+    },
+
+
+    /** 
+     * Gets tile, which contains the center of the viewport.
+     *
+     * Default function; will override in subclasses,
+     * otherwise it returns null - that means: no scaling possible!
+     * 
+     * @returns returns null if no center tile set
+     * @type OpenLayers.Tile
+     */
+    getCenterTile:function() {
+        return null;
+    },
+
+
+    /** 
+     * Sets all tiles outside the viewport invisible. 
+     * Only for baselayers with a grid of tiles.
+     *
+     * Default function; will override in subclasses,
+     * otherwise it returns false
+     * 
+     * @returns false if baselayer has no grid
+     * @type Boolean
+     */
+    setTilesOutsideInvisible:function() {
+        return false;
+    },
+
+    /**
+     * Scales tile to the new tile size (changes size and position).
+     * If you have a grid, the tile is the center tile. Otherwise it's
+     * the only one.
+     * 
+     * @param {OpenLayers.Tile} tile
+     * @param {OpenLayers.Size} newTileSize
+     * 
+     * @returns true if tile is scaled, otherwise false
+     * @type Boolean
+     */
+    scaleTileTo:function(tile, newTileSize) {
+        //convert the center of the map in pixel
+        var centerPx = this.map.getPixelFromLonLat(this.map.getCenter());
+
+        //reposition and resize the tile 
+        if (tile) {
+            if ((newTileSize.w < Math.pow(2,15)) &&
+                (newTileSize.h < Math.pow(2,15)) ){
+
+                // set real start position of centerTile
+                var startPosX = (tile.position.x +
+                  parseInt(this.map.layerContainerDiv.style.left));
+                // set new left position
+                var leftOffset = newTileSize.w / tile.size.w
+                  * (centerPx.x - startPosX);
+                leftOffset = Math.round(leftOffset);
+                var newLeftPos = centerPx.x - leftOffset
+                  - parseInt(this.map.layerContainerDiv.style.left);
+                tile.imgDiv.style.left = Math.round(newLeftPos) + "px";
+
+                // set real start position of centerTile
+                var startPosY = (tile.position.y +
+                  parseInt(this.map.layerContainerDiv.style.top));
+                //set new top position
+                var topOffset = newTileSize.h / tile.size.h
+                  * (centerPx.y - startPosY);
+                topOffset = Math.round(topOffset);
+                var newTopPos = centerPx.y - topOffset 
+                  - parseInt(this.map.layerContainerDiv.style.top);
+                tile.imgDiv.style.top = Math.round(newTopPos) + "px";
+
+                //set new width and height
+                tile.imgDiv.style.width = Math.round(newTileSize.w) + "px";
+                tile.imgDiv.style.height = Math.round(newTileSize.h) + "px";
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }, 
+
+    /** 
+     * Scales all tiles of a grid to the new tile size 
+     * (changes size and position).
+     *
+     * Default function; will override in subclasses,
+     * otherwise it returns false
+     * 
+     * @param {OpenLayers.Tile} centerTile
+     * @param {OpenLayers.Size} newTileSize
+     *
+     * @returns false if no grid is scaled
+     * @type Boolean
+     */
+    scaleTilesOfGrid:function(centertile, newTileSize) {
+        return false;
+    },
+
+
+    /**
+     * Reposition and resize the zoomOut tile to prevent a white frame
+     * during zoomOut.
+     *
+     * @param {float} newZoomlevel
+     * @param {float} newResolution
+     *
+     * @returns false if no zoomOutTile scaled
+     * @type Boolean
+     */
+    scaleZoomOutTile: function(newZoomlevel, newResolution) {
+        return false;
+    },
+
+    /**
+     * The actual zoomOutTile scale function:
+     * Reposition and resize the zoomOut tile to prevent a white frame
+     * during zoomOut.
+     *
+     * special function; shares with some baselayers; calls from subclasses
+     *
+     * @param {float} newZoomlevel
+     * @param {float} newResolution
+     *
+     * @returns true after the zoomOutTile is scaled
+     * @type Boolean
+     */
+    scaleZoomOutTile_share: function(newZoomlevel, newResolution) {
+
+        //convert the current center of the map in pixel
+        var centerPx = this.map.getPixelFromLonLat(this.map.getCenter());
+
+
+        var newTileSize = new OpenLayers.Size();
+        newTileSize.w = Math.round(this.map.tileSize.w * Math.pow(2, newZoomlevel));
+        newTileSize.h = Math.round(this.map.tileSize.h * Math.pow(2, newZoomlevel));
+
+        // handles bug in ie: 
+        // turn zoomOut tile scale off, if tileSize > 2^15 
+        var ieBug;
+        if (navigator.appName == "Microsoft Internet Explorer"){ 
+            if ((newTileSize.w > Math.pow(2,15)) &&
+                (newTileSize.h > Math.pow(2,15)) ){
+                ieBug = true;
+                this.map.baseLayer.zoomOutTile.imgDiv.style.display = "none";
+            }
+            else {
+                ieBug = false;
+            }
+        }
+        else {
+            ieBug = false;
+        }
+
+        if (!ieBug && !this.firstCall) {
+            //set new size (width and height)
+            this.zoomOutTile.imgDiv.style.width = newTileSize.w + "px";          
+            this.zoomOutTile.imgDiv.style.height = newTileSize.h + "px";
+
+            //set new position (top and left)
+            var bounds = this.zoomOutTile.bounds;
+            var extent = this.map.getExtent();
+            var maxExtent = this.map.getMaxExtent();
+
+            var resolution = this.map.getMaxResolution();
+            var centerLonLat = extent.getCenterLonLat();
+             
+            var offsetlon = bounds.left - centerLonLat.lon;
+            var offsetlat = -bounds.top + centerLonLat.lat;
+            
+            var offsetx = offsetlon / newResolution
+              - parseInt(this.map.layerContainerDiv.style.left);
+            var offsety = offsetlat / newResolution
+              - parseInt(this.map.layerContainerDiv.style.top);
+            
+            this.zoomOutTile.imgDiv.style.left = 
+                Math.round(centerPx.x + offsetx) + "px";  
+            this.zoomOutTile.imgDiv.style.top = 
+                Math.round(centerPx.y + offsety) + "px";
+        
+            
+            this.map.baseLayer.zoomOutTile.imgDiv.style.display = "block";
+        }
+        
+        return true;
+    },
+
+    /** 
+     * Clones layerContainer for "smooth tile update".
+     * So, it gets no blank map while map is loading in new zoomlevel.
+     *
+     * Default function; will override in subclasses,
+     * otherwise it returns false
+     * 
+     * @returns false if no layerContainer cloned
+     * @type Boolean
+     */
+    cloneBaseLayerDiv:function() {
+        return false;
+    },
+
+    /** 
+     * The actual clone function:
+     * Hold scaled map while tiles are loading successive.
+     *  
+     * special function; shares with some baselayers; calls from subclasses
+     *
+     */
+    cloneBaseLayerDiv_share:function() {
+        // function for map only; not for overviewmap!
+        if (this.map.div.id == "map") {  
+            
+            // 1. clone baseLayerDiv with all childs (replace, if already exist)
+            if (this.map.baseLayerDivClone){
+                this.map.layerContainerDiv.removeChild(this.map.baseLayerDivClone);
+                this.map.baseLayerDivClone = null;
+            }
+            this.map.baseLayerDivClone = this.map.baseLayer.div.cloneNode(true);
+            this.map.baseLayerDivClone.id =
+                this.map.baseLayer.div.id + "_clone";
+                    
+    
+            // 2. append baseLayerDivClone to layerContainer
+            // (now the cloned div is above the original; it hides the original)
+            this.map.layerContainerDiv.appendChild(this.map.baseLayerDivClone);
+
+            // 3. set zIndex 
+            this.map.baseLayerDivClone.style.zIndex--; 
+                
+            // 4. set zoomOut tile (of original div) invisible 
+            if (this.map.baseLayer.zoomOutTile)
+                this.map.baseLayer.zoomOutTile.imgDiv.style.display = "none";
+
+            // 5. adjust left and top position 
+            // (if map is panning before, layerContainer is displaced)
+            if (this.map.layerContainerDiv.style.left != "")
+                this.map.baseLayerDivClone.style.left += 
+                    parseInt(this.map.layerContainerDiv.style.left);
+            if (this.map.layerContainerDiv.style.top != "")
+                this.map.baseLayerDivClone.style.top += 
+                    parseInt(this.map.layerContainerDiv.style.top);           
+        }
+    },
+
+
+    /**
+     * Sets visibility of map after zoomend/loadend:
+     * - freezed/cloned layerContainer invisible
+     * - zoomOutTile invisibile
+     * 
+     * Calls automatically after fire loadend event. 
+     */
+    setLoadendVisibility: function() {
+        // set flag that zoom animation finished
+        this.map.zoomanimationActive = false;
+
+        // function for map only; not for overviewmap!
+        if (this.map.div.id == "map") {        
+            // remove cloned baseLayerDiv
+            if (this.map.baseLayerDivClone){
+                this.map.layerContainerDiv.removeChild(this.map.baseLayerDivClone);
+                this.map.baseLayerDivClone = null;
+            }
+        }
+        
+        // after map is loaded the first time the flag sets to false
+        // (reason: zoomOutTile shouldn't visible by first zoom/scale)
+        if (this.firstCall)
+            this.firstCall = false;
+    },
+
+
-    /** @final @type String */
-    CLASS_NAME: "OpenLayers.Layer"
-};

lib/OpenLayers/Map.js

@@ -62 +62 @@
-    /** @type HTMLDivElement */
-    layerContainerDiv: null,
-
+    /** @type HTMLDivElement */
+    baseLayerDivClone: null, 
+
-    /** ordered list of layers in the map
-     * 
-     * @type Array(OpenLayers.Layer)
@@ -136 +139 @@
-    /** @type string */
-    theme: null,
-
+
+    //ANIMATION
+    
+    /** @type Boolean */
+    animated: true,
+
+    /** steps in the slide
+     * 
+     * @type int */
+    slideSteps: 4,  
+    
+    /** millisecondss between each step
+     * 
+     * @type int */
+    slideWait: 1,
+
+    /** power used to calculate width of slide steps
+     * 
+     * @type float*/
+    slidePower: 0.7,
+
+
+    /** @type int */
+    animatedZoomingIntervalID: null,
+
+
+    /** @type boolean */
+    zoomanimationActive: false,
+
+    /** @type int */
+    zoomOutTileSizeFactor: 4,
+
+    /** @type int */
+    zoomlevel_startScale: null,  
+    
+    /** @type float */
+    zoomlevel_scale: null,   
+     
+    /** @type OpenLayers.Size */
+    tileSize_startScale: null, 
+    
+    /** @type OpenLayers.Size */
+    tileSize_scale: null,
+ 
+    /** @type OpenLayers.Tile */
+    centerTile: null,
+    
+    /** @type float */
+    resolution_scale: null,
+
+
-    /** Should OpenLayers allow events on the map to fall through to other
-     *   elements on the page, or should it swallow them? (#457)
-     * 
@@ -182 +236 @@
-
-        this.updateSize();
- 
-
-
-
+    
+    
+    
-        if (navigator.appName.contains("Microsoft")) {
-            // If IE, register the resize on the div
-            this.events.register("resize", this, this.updateSize);
@@ -229 +283 @@
-
-        // always call map.destroy()
-        OpenLayers.Event.observe(window, 'unload', this.unloadDestroy);
-
+
+
+
-    },
-
-    /**
@@ -511 +567 @@
-
-                // set new baselayer and make it visible
-                this.baseLayer = newBaseLayer;
+
+                // preload a bigger tile for zooming out (not supported
+                // for every baselayer! for map only; not for ovmap!)
+                if (this.div.id == "map")
+                    this.baseLayer.setZoomOutTile(); 
-                
-                // Increment viewRequestID since the baseLayer is 
-                // changing. This is used by tiles to check if they should 
-                // draw themselves.
-                this.viewRequestID++;
+
+                // make new baselayer visible
-                this.baseLayer.setVisibility(true, noEvent);
-
-                //redraw all layers
@@ -655 +718 @@
-                var centerLL = this.getLonLatFromViewPortPx(center);
-                var zoom = this.getZoom();
-                this.zoom = null;
-
+
+
+
+
+
-            }
-
-        }
@@ -872 +939 @@
-        }
-    },
-
+
+    /** Position changer with Memory by www.hesido.com
+     *  modified by dncpax for OpenLayers
+     * 
+     * @param {int} slideZoom
+     * @param {int} totalSteps
+     * @param {int} intervals
+     * @param {float} power 
+     */
+    zoomSlide: function( slideZoom, totalSteps, interval, power) {
+        if (this.animatedZoomingIntervalID) {
+            window.clearInterval(this.animatedZoomingIntervalID);
+            this.animatedZoomingIntervalID = null;
+        }
+        var context = {
+            'map': this,
+            'slideZoom': slideZoom,
+            'totalSteps': totalSteps,
+            'step': 0,
+            'power': power
+        };
+        var move = function() {
+            var delta = this.slideZoom - this.map.zoom;
+            var dZoom = OpenLayers.Util.easeInOutZoom(delta, 
+                                                this.totalSteps, 
+                                                this.step, 
+                                                this.power);
+
+            this.map.zoomTo(this.map.zoom + dZoom, false, this.step);
+            this.step++;
+            if (this.step > this.totalSteps) {
+                window.clearInterval(this.map.animatedZoomingIntervalID);
+                this.map.animatedZoomingIntervalID = null;
+            }
+        };
+
+        this.animatedZoomingIntervalID = 
+            window.setInterval(move.bindAsEventListener(context), 
+                               interval);
+    },
+
+
-    /**
-     * @private 
-     * 
@@ -906 +1015 @@
-        return valid;
-    },
-
+
-  /********************************************************/
-  /*                                                      */
-  /*                 Layer Options                        */
@@ -1058 +1168 @@
-  
-    /** Zoom to a specific zoom level
-     * 
-
+
+
+
+
-     */
-
+, animated, step
-        if (this.isValidZoomLevel(zoom)) {
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-    },
-    
-    /**
-     * @param {int} zoom
-     */
-
-
+
+
+
+
+
+
-    },
-    
-    /**
-     * @param {int} zoom
-     */
-
-
+
+
+
+
+
+
-    },
-
-    /** Zoom to the passed in bounds, recenter
@@ -1085 +1236 @@
-     * @param {OpenLayers.Bounds} bounds
-     */
-    zoomToExtent: function(bounds) {
-
-
+
+
+
+
+
+
+
+
-    },
-
-    /** Zoom to the full extent and recenter.
@@ -1113 +1270 @@
-                                           center.lat + h_deg / 2);
-        this.zoomToExtent(extent);
-    },
+ 
-    
+    /**
+     * get and set some settings for zoom animation
+     *
+     *
+     */
+    prepareZoomAnimation:function() {
+        // begin zoom animation -> set flag
+        this.zoomanimationActive = true;
+        
+        // get current zoomlevel
+        this.zoomlevel_startScale = this.zoom;
+
+        // get current tile size (it's the base for scaling)
+        this.tileSize_startScale = this.baseLayer.getTileSize();
+      
+        // get tile, which contains the center of the viewport
+        this.centerTile = this.baseLayer.getCenterTile();   
+
+        // set all active overlays temporarily invisible
+        for (var i = 0; i < this.layers.length; i++) {
+            var layer = this.layers[i];
+            if (!layer.isBaseLayer) {
+                this.layers[i].div.style.display = "none";
+            }
+        }       
+
+        // set all tiles outside the viewport invisible
+        // (only for baselayers with grid of tiles)
+        this.baseLayer.setTilesOutsideInvisible();
+    },
+
+    /**
+     * run zoom animation -> scale tile(s)   
+     *
+     * @param {int} zoomStopHeight
+     * @param {OpenLayers.Pixel} sliderPosition
+     */
+    runZoomAnimation:function(zoomStopHeight, sliderPosition) {
+        // scale baselayer if tileSize and centerTile is set
+        if ( this.tileSize_startScale && this.centerTile ) {
+
+            // determine zoomlevel (only if slider used ->zoomStopHeight exists)
+            if (zoomStopHeight && sliderPosition )
+                this.calculateNewZoomlevel(zoomStopHeight,sliderPosition);
+           
+            // determine tile size and map resolution
+            this.calculateNewTileSize();
+
+            // get tile, which contains the center of the viewport again
+            // (it's necessary for synchronous animated panning and zooming)
+            if (!zoomStopHeight)
+                this.centerTile = this.baseLayer.getCenterTile();  
+
+            // scale (center) tile to new scaled size   
+            this.baseLayer.scaleTileTo(this.centerTile, 
+                                            this.tileSize_scale);
+            
+            // scale all tiles to new scaled size (if there
+            // are more than one tile)
+            this.baseLayer.scaleTilesOfGrid(this.centerTile, 
+                                            this.tileSize_scale);
+
+            // scale zoomOut tile (to prevent a white frame during zoomOut)
+            this.baseLayer.scaleZoomOutTile(this.zoomlevel_scale, 
+                                            this.resolution_scale);
+
+            // set new scaled map resolution (important for overviewmap)
+            this.setScaleResolution(this.resolution_scale);
+
+            // update zoom slider position (only if slider NOT used ->
+            // zoomStopHeight not exisits)
+            if (!zoomStopHeight){
+                for (i=0; i<this.controls.length; i++) {
+                    if (this.controls[i].CLASS_NAME == "OpenLayers.Control.PanZoomBar") 
+                        this.controls[i].moveZoomBar(this.zoomlevel_scale);
+                }  
+            }
+        }
+    },
+
+     /**
+     * finish zoom animation
+     * 
+     * @param {int} finalZoomlevel
+     */
+    finishZoomAnimation:function(finalZoomlevel) {
+        // clone layerContainer for "smooth tile update" without blank map
+        this.baseLayer.cloneBaseLayerDiv();
+       
+        // zooom to final zoomlevel 
+        if (this.isValidZoomLevel(finalZoomlevel))
+            this.setCenter(null, finalZoomlevel);
+
+        // set zoomanimation flag to false _manually_ 
+        // (only for baselayers without onimageload events, f.e. imagelayer
+        // and for ie, where the loadend event doesn't works correctly);
+        // for all other layers it calls automatically from
+        // loadendevent in layers.js
+        if (this.baseLayer.CLASS_NAME.match("OpenLayers.Layer.Image") ||
+            (navigator.appName == "Microsoft Internet Explorer") ){
+            this.zoomanimationActive = false;
+        }
+    },
+
+
+    /**
+     * Calculates new zoomlevel of current zoomslider position.
+     * 
+     * @param {int} zoomStopHeight
+     * @param {OpenLayers.Pixel} sliderPosition
+     */
+    calculateNewZoomlevel:function(zoomStopHeight, sliderPosition) {
+        // convert current sliderposition to new zoomlevel
+        var deltaY_zoomlevel = this.zoomStart.y - sliderPosition.y;
+        this.zoomlevel_scale = this.zoomlevel_startScale + 
+          deltaY_zoomlevel/zoomStopHeight;
+       
+        // check zoomlevel validity 
+        if (this.zoomlevel_scale < 0) {
+            this.zoomlevel_scale = 0; 
+        } 
+        if (this.zoomlevel_scale > (this.getNumZoomLevels()- 1)) { 
+            this.zoomlevel_scale = this.getNumZoomLevels() - 1; 
+        }
+    },
+
+
+    /**
+     * Calculates new tile size and map resolution of current zoomlevel.
+     *
+     */
+    calculateNewTileSize:function() {
+        // calculate new tile size for...
+        // ...zoomIn
+        if (this.zoomlevel_startScale < this.zoomlevel_scale) {
+            this.tileSize_scale.w = Math.pow(2,(this.zoomlevel_scale -
+              this.zoomlevel_startScale)) * this.tileSize_startScale.w;
+            this.tileSize_scale.h = Math.pow(2,(this.zoomlevel_scale -
+              this.zoomlevel_startScale)) * this.tileSize_startScale.h;
+
+            // set new map resolution
+            this.resolution_scale = 1/(Math.pow(2,(this.zoomlevel_scale - 
+              this.zoomlevel_startScale))) *  this.getResolution();    
+        }
+        // ...zoomOut / no zoom changes
+        if (this.zoomlevel_startScale >= this.zoomlevel_scale) {             
+            this.tileSize_scale.w = 1/(Math.pow(2,(this.zoomlevel_startScale -
+              this.zoomlevel_scale))) * this.tileSize_startScale.w;
+            this.tileSize_scale.h = 1/(Math.pow(2,(this.zoomlevel_startScale - 
+              this.zoomlevel_scale))) * this.tileSize_startScale.h;
+
+            // set new map resolution
+            this.resolution_scale = Math.pow(2,(this.zoomlevel_startScale - 
+              this.zoomlevel_scale)) * this.getResolution(); 
+        }
+    },
+
+
+
-  /********************************************************/
-  /*                                                      */
-  /*             Translation Functions                    */

lib/OpenLayers/Util.js

@@ -965 +965 @@
-    }
-    return head;
-};
+
+
+/** Generic Animation Step Value Generator By www.hesido.com, slightly modified
+ * 
+ * 
+ * @param {int} delta
+ * @param {int} totalSteps
+ * @param {int} step
+ * @param {float} power
+ * 
+ * @returns The next zoomlevel in the zoom animation movement
+ * @type float
+ */
+OpenLayers.Util.easeInOutZoom = function(delta, totalSteps, step, power) {
+    var stepVal = Math.pow(((1/totalSteps)*step),power) * delta;
+    return stepVal; 
+};

lib/OpenLayers/Layer/WMS.js

@@ -86 +86 @@
-    
-    /**
-     * @param {OpenLayers.Bounds} bounds
+     * @param {OpenLayers.Size} tileSize
-     * 
-     * @returns A string with the layer's url and parameters and also the 
-     *           passed-in bounds and appropriate tile size specified as 
-     *           parameters
-     * @type String
-     */
-
+
+
+
+
-        return this.getFullRequestString(
-                     {BBOX:bounds.toBBOX(),
-his.t
-his.t
+
+
-    },
-
-    /**

lib/OpenLayers/Layer/Grid.js

@@ -23 +23 @@
-    /** @type Integer */
-    buffer: 2,
-
+    /** @type Integer */
+    centerRow: null,
+
+    /** @type Integer */
+    centerCol: null,
+
-    /**
-     * @constructor
-     * 
@@ -290 +296 @@
-     *   Once all the grid's tiles have been added to the queue, we go back 
-     *    and iterate through the queue (thus reversing the spiral order from 
-     *    outside-in to inside-out), calling draw() on each tile. 
+     *
+     *   Fires loadend event after all tiles in viewport loaded.
-     */
-    spiralTileLoad: function() {
-        var tileQueue = new Array();
@@ -344 +352 @@
-                directionsTried++;
-            }
-        } 
-
+
+
+
+
+
+
+
+
+
-        // now we go through and draw the tiles in forward order
-        for(var i=0; i < tileQueue.length; i++) {
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-    },
-
+
-    /**
-     * addTile gives subclasses of Grid the opportunity to create an 
-     * OpenLayer.Tile of their choosing. The implementer should initialize 
@@ -447 +511 @@
-            }
-        }
-    },
+
+
+
+    /********************************************************/
+    /*                                                      */
+    /*       Baselayer Functions for zooming/scaling        */
+    /*                                                      */
+    /********************************************************/    
+
+    /** 
+     * Initializes zoomOut tile and sets a x-times bigger tile size.
+     *
+     * @returns true after zoomOutTile is set
+     * @type Boolean
+     */
+    setZoomOutTile:function() {
+        this.setZoomOutTile_share();
+        return true;
+    },
+
+    /** 
+     * Gets the current tile size of the layer.
+     *  
+     * @returns the current map tile size
+     * @type OpenLayers.Size
+     */
+    getTileSize:function() {
+        return this.map.getTileSize();
+    },
+
+    /** 
+     * Gets tile, which contains the center of the viewport.
+     *
+     * @returns the tile, which contains the center of the viewport
+     * @type OpenLayers.Tile
+     */
+    getCenterTile:function() {
+        var center = this.map.getCenter();
+
+        if (this.grid) {
+            for (var iRow=0; iRow < this.grid.length; iRow++) {
+                for (var iCol=0; iCol < this.grid[iRow].length; iCol++) {
+                    var tileBounds = this.grid[iRow][iCol].bounds;
+                    if (tileBounds.containsLonLat(center, true)) {
+                        this.centerRow = iRow;
+                        this.centerCol = iCol;
+                        return this.grid[iRow][iCol];                    
+                    }
+                }
+            }
+        }
+        return false;   // something runs fail!
+    },
-    
+
+    /** 
+     * Sets all tiles outside the viewport invisible. 
+     * Only for baselayers with a grid of tiles.
+     * 
+     * @returns true if tiles are set invisible
+     * @type Boolean
+     */
+    setTilesOutsideInvisible:function() {
+        var extent = this.map.getExtent();
+        var layerGrid = this.map.baseLayer.grid;
+
+        // go through the whole grid
+        for (var iRow=0; iRow < layerGrid.length; iRow++) {
+            for (var iCol=0; iCol < layerGrid[iRow].length; iCol++) {                         
+                var tile = layerGrid[iRow][iCol];
+                if (tile.imgDiv) {
+                    // scale all (visible) tiles within the viewport
+                    if (!extent.containsBounds(tile.bounds,true, false))
+                        tile.imgDiv.style.display = "none";
+                }
+            }
+        }                
+        return true;
+    },
+
+
+    /**
+     * Scales all tiles of a grid to the new tile size 
+     * (changes size and position).
+     * 
+     * @param {OpenLayers.Tile} centerTile
+     * @param {OpenLayers.Size} newTileSize
+     *
+     * @returns true after the grid is scaled
+     * @type Boolean
+     */
+    scaleTilesOfGrid:function(centerTile, newTileSize) {
+
+        var extent = this.map.getExtent();
+
+        // reposition and resize all _visible_ tiles of the active baselayer
+        var layerGrid = this.map.baseLayer.grid;
+
+        // go through the whole grid
+        for (var iRow=0; iRow < layerGrid.length; iRow++) {
+            for (var iCol=0; iCol < layerGrid[iRow].length; iCol++) {                         
+                var tile = layerGrid[iRow][iCol];
+                if (tile.imgDiv) {
+                    if ((newTileSize.w < Math.pow(2,15)) &&
+                        (newTileSize.h < Math.pow(2,15)) ){
+
+                        // scale all (visible) tiles within the viewport
+                        if (extent.containsBounds(tile.bounds,true, false)) {
+                            //define the factors for rows and columns
+                            //(relates to the center tile)
+                            var deltaRow = iRow - this.centerRow;
+                            var deltaCol = iCol - this.centerCol;
+                            
+                            //set new left position
+                            var newLeftPos = parseInt(centerTile.imgDiv.style.left)
+                              + deltaCol * newTileSize.w ;
+                            tile.imgDiv.style.left = Math.round(newLeftPos) + "px";
+
+                            //set new top position
+                            var newTopPos = parseInt(centerTile.imgDiv.style.top)
+                              + deltaRow * newTileSize.h ;
+                            tile.imgDiv.style.top = Math.round(newTopPos) + "px";
+
+                            //set new width and height
+                            tile.imgDiv.style.width = Math.round(newTileSize.w) + "px";
+                            tile.imgDiv.style.height = Math.round(newTileSize.h) + "px";
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    },
+    
+    /**
+     * Reposition and resize the zoomOut tile to prevent a white frame
+     * during zoomOut.
+     * share scale algorithm with other baselayers
+     *
+     * @param {float} newZoomlevel
+     * @param {float} newResolution
+     *
+     * @returns true if zoomOutTile is scaled, otherwise false
+     * @type Boolean
+     */
+    scaleZoomOutTile: function(newZoomlevel, newResolution) {
+        if (this.zoomOutTile) {
+            this.scaleZoomOutTile_share(newZoomlevel, newResolution);
+            return true;
+        }
+        else { 
+            return false;
+        }
+    },
+
+    /** 
+     * Clones layerContainer for "smooth tile update". 
+     * So, it gets no blank map while map is loading in new zoomlevel.
+     *
+     * @returns true after layerContainer is cloned
+     * @type Boolean
+     */
+    cloneBaseLayerDiv:function() {
+        // share clone algorithm with other baselayers
+        this.cloneBaseLayerDiv_share();
+
+        // remove all old imgDiv tiles 
+        // (so it doesn't becomes complicate with the same imgDivs of the
+        // cloned layerContainerDiv)
+        for (iRow=0; iRow<this.grid.length; iRow++){
+            for (iCol=0; iCol<this.grid[iRow].length; iCol++){
+                var tile = this.grid[iRow][iCol];
+                if (tile.imgDiv)
+                    this.div.removeChild(tile.imgDiv);
+            }
+        }       
+        //reset grid array
+        this.grid = new Array();
+
+        return true;
+    },
+
+
+     
-    /** @final @type String */
-    CLASS_NAME: "OpenLayers.Layer.Grid"
-});