Changeset 2263

Timestamp:

02/22/07 11:03:47 (2 years ago)

Author:

emanuel

Message:

version 1.3

Files:

• sandbox/emanuel/animatedZooming (copied) (copied from trunk/openlayers)
• sandbox/emanuel/animatedZooming/demo.html (added)
• sandbox/emanuel/animatedZooming/demo_frida.html (added)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Control/OverviewMap.js (modified) (4 diffs)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Control/PanZoomBar.js (modified) (5 diffs)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Layer.js (modified) (2 diffs)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Layer/Grid.js (modified) (6 diffs)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Layer/Image.js (modified) (1 diff)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Layer/WMS.js (modified) (2 diffs)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Layer/WMS/Untiled.js (modified) (3 diffs)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Map.js (modified) (11 diffs)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Tile/Image.js (modified) (1 diff)
• sandbox/emanuel/animatedZooming/lib/OpenLayers/Util.js (modified) (1 diff)

sandbox/emanuel/animatedZooming/lib/OpenLayers/Control/OverviewMap.js

@@ -385 +385 @@
-                (this.ovmap.getExtent().containsBounds(testExtent)));
-    },
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        var targetRes = this.ovmap.getResolution();
-        var resRatio = targetRes / mapRes;
@@ -399 +410 @@
-        this.ovmap.setCenter(this.map.center,
-                            this.ovmap.getZoomForResolution(targetRes));
-
+bounds
-    },
-    
@@ -423 +434 @@
-        
-    /**
-
-
-
+
+
+
+
+
+
+
-        // The base layer for overview map needs to be in the same projection
-        // as the base layer for the main map.  This should be made more robust.
@@ -433 +448 @@
-            }
-        }
-
+
+
+
+
-        if (pxBounds) {
-          this.setRectPxBounds(pxBounds);

sandbox/emanuel/animatedZooming/lib/OpenLayers/Control/PanZoomBar.js

@@ -24 +24 @@
-    zoomStopHeight: 11,
-
+    /** @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,
+
-    initialize: function() {
-        OpenLayers.Control.PanZoom.prototype.initialize.apply(this, arguments);
-        this.position = new OpenLayers.Pixel(OpenLayers.Control.PanZoomBar.X,
-                                             OpenLayers.Control.PanZoomBar.Y);
+        this.tileSize_scale = new OpenLayers.Size();
-    },
-
@@ -168 +187 @@
-        this.zoomStart = evt.xy.clone();
-        this.div.style.cursor = "move";
+        
+        // get current zoomlevel
+        this.zoomlevel_startScale = this.map.zoom;
+
+        // get current tile size (it's the base for scaling)
+        this.tileSize_startScale = this.map.baseLayer.getTileSize();
+      
+        // get tile, which contains the center of the viewport
+        this.centerTile = this.map.baseLayer.getCenterTile();   
+
+        //set all active overlays temporarily invisible
+        for (var i = 0; i < this.map.layers.length; i++) {
+            var layer = this.map.layers[i];
+            if (!layer.isBaseLayer) {
+                this.map.layers[i].div.style.display = "none";
+            }
+        }        
+        
-        OpenLayers.Event.stop(evt);
-    },
@@ -187 +224 @@
-            }
-            this.mouseDragStart = evt.xy.clone();
+            
+            
+            // scale baselayer if tileSize and centerTile is set
+            if ( this.tileSize_startScale && this.centerTile ) {
+
+                // determine zoomlevel
+                this.calculateNewZoomlevel(evt);
+               
+                // determine tile size and map resolution
+                this.calculateNewTileSize();
+
+                // scale (center) tile to new scaled size   
+                this.map.baseLayer.scaleTileTo(this.centerTile, 
+                                                        this.tileSize_scale);
+                
+                // scale all tiles to new scaled size (if there
+                // are more than one tile)
+                this.map.baseLayer.scaleTilesOfGrid(this.centerTile, 
+                                                        this.tileSize_scale);
+
+                // scale zoomOut tile (to prevent a white frame during zoomOut)
+                this.map.baseLayer.scaleZoomOutTile(this.tileSize_scale,
+                                                        this.zoomlevel_scale, 
+                                                        this.resolution_scale);
+
+                // set new scaled map resolution (important for overviewmap)
+                this.map.setScaleResolution(this.resolution_scale);
+            }
+
-            OpenLayers.Event.stop(evt);
-        }
@@ -203 +269 @@
-            this.map.events.unregister("mousemove", this, this.passEventToSlider);
-            var deltaY = this.zoomStart.y - evt.xy.y
+  
+            // clone layerContainer for "smooth tile update" without blank map
+            this.map.baseLayer.cloneLayerContainer();
+
+            // zoom map to new zoomlevel
-            this.map.zoomTo(this.map.zoom + Math.round(deltaY/this.zoomStopHeight));
-            this.moveZoomBar();
@@ -210 +281 @@
-    },
-    
+    
+    /**
+     * Calculates new zoomlevel of current zoomslider position.
+     *
+     */
+    calculateNewZoomlevel:function(evt) {
+        // convert current sliderposition to new zoomlevel
+        var deltaY_zoomlevel = this.zoomStart.y - evt.xy.y;
+        this.zoomlevel_scale = this.zoomlevel_startScale + 
+          deltaY_zoomlevel/this.zoomStopHeight;
+       
+        // check zoomlevel validity 
+        if (this.zoomlevel_scale < 0) {
+            this.zoomlevel_scale = 0; 
+        } 
+        if (this.zoomlevel_scale > (this.map.getNumZoomLevels()-1)) { 
+            this.zoomlevel_scale = this.map.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.map.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.map.getResolution(); 
+        }
+    },
+
+
-    /* 
-    * Change the location of the slider to match the current zoom level.

sandbox/emanuel/animatedZooming/lib/OpenLayers/Layer.js

@@ -131 +131 @@
-            this.div.id = this.id;
-        }
-
-
+
+
+
+
-    },
-    
@@ -577 +579 @@
-        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;
+        }
+    },
+ 
+    /** 
+     * 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;
+    },
+
+    /** 
+     * 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
+     */
+    cloneLayerContainer:function() {
+        return false;
+    },
+
+    /** 
+     * The actual clone function:
+     * Freeze current map while tiles of viewport are loading.
+     *  
+     * special function; shares with some baselayers; calls from subclasses
+     *
+     */
+    cloneLayerContainer_share:function() {
+         // 1. clone layerContainerDiv with all childs (replace, if already exist)
+        if (this.map.layerContainerDivClone){
+            this.map.viewPortDiv.removeChild(this.map.layerContainerDivClone);
+            this.map.layerContainerDivClone = null;
+        }
+        this.map.layerContainerDivClone = this.map.layerContainerDiv.cloneNode(true);
+        this.map.layerContainerDivClone.id = "map_OpenLayers_Container_clone";
+        // 2. append layerContainerDivClone to viewPortDiv
+        // (now the cloned div is above the original; it hides the original)
+        this.map.viewPortDiv.appendChild(this.map.layerContainerDivClone);
+    },
+
+
+    /**
+     * Sets visibility after zoomend/loadend:
+     * - freezed/cloned layerContainer invisible
+     * - zoomOutTile invisibile
+     * Calls automatically after fire loadend event. 
+     */
+    setLoadendVisibility: function() {
+        // set cloned layerDiv invisibile -> original div is visible               
+        if (this.map.layerContainerDivClone){
+            this.map.layerContainerDivClone.style.display= "none";
+        }
+
+        // set zoomOutTile invisible
+        if (this.map.baseLayer.zoomOutTile){
+            this.map.baseLayer.zoomOutTile.imgDiv.style.display = "none";
+        }
+    },
+
+    /** 
+     * 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;
+    },
+
+    /**
+     * 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) {
+            // 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 = 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 = newTopPos + "px";
+
+             //set new width and height
+            tile.imgDiv.style.width = newTileSize.w + "px";
+            tile.imgDiv.style.height = 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 {OpenLayers.Size} newTileSize
+     * @param {float} newZoomlevel
+     * @param {float} newResolution
+     *
+     * @returns false if no zoomOutTile scaled
+     * @type Boolean
+     */
+    scaleZoomOutTile: function(newTileSize, 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 {OpenLayers.Size} newTileSize
+     * @param {float} newZoomlevel
+     * @param {float} newResolution
+     *
+     * @returns true after the zoomOutTile is scaled
+     * @type Boolean
+     */
+    scaleZoomOutTile_share: function(newTileSize, newZoomlevel, newResolution) {
+
+        //convert the current center of the map in pixel
+        var centerPx = this.map.getPixelFromLonLat(this.map.getCenter());
+   
+        //set new size (width and height)
+        this.zoomOutTile.imgDiv.style.width = this.map.tileSize.w 
+          * Math.pow(2, newZoomlevel) + "px";
+        this.zoomOutTile.imgDiv.style.height = this.map.tileSize.h 
+          * Math.pow(2, newZoomlevel) + "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();
+         
+        if( bounds.containsLonLat(centerLonLat)
+            && !(extent.equals(maxExtent))) {
+            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 = centerPx.x + offsetx + "px";  
+            this.zoomOutTile.imgDiv.style.top = centerPx.y + offsety + "px";
+            
+            // set zoomOutTile visible if viewport < map bounds
+            if ( (bounds.left < extent.left) || (bounds.right > extent.right) ) 
+                this.map.baseLayer.zoomOutTile.imgDiv.style.display = "block";
+            else
+                this.map.baseLayer.zoomOutTile.imgDiv.style.display = "none";
+        }
+        
+        return true;
+    },
+
-
-    /** @final @type String */

sandbox/emanuel/animatedZooming/lib/OpenLayers/Layer/Grid.js

@@ -23 +23 @@
-    /** @type Integer */
-    buffer: 2,
+
+    /** @type Integer */
+    centerRow: null,
+
+    /** @type Integer */
+    centerCol: null,
-
-    /**
@@ -139 +145 @@
-        }
-    },
+     
-    
-    /**
@@ -259 +266 @@
-            }
-        }
-
+
+
-        //now actually draw the tiles
-        this.spiralTileLoad();
@@ -274 +282 @@
-     *    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() {
@@ -314 +324 @@
-            
-            if ((tile != null) && (!tile.queued)) {
-
+ 
-                tileQueue.unshift(tile);
-                tile.queued = true;
-                
-
+ 
-                directionsTried = 0;
-                iRow = testRow;
-                iCell = testCell;
-            } else {
-
+ 
-                direction = (direction + 1) % 4;
-                directionsTried++;
-            }
-        } 
-
+
+
+
+
+
+
+
+
+
-        // now we go through and draw the tiles in forward order
-        for(var i=0; i < tileQueue.length; i++) {
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-    },
@@ -449 +513 @@
-    },
-    
+
+
+    /********************************************************/
+    /*                                                      */
+    /*       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() {
+        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(this.map.getCenter(), true)) {
+                        this.centerRow = iRow;
+                        this.centerCol = iCol;
+                        return this.grid[iRow][iCol];                    
+                    }
+                }
+            }
+        }
+        return false;   // something runs fail!
+    },
+    
+    /**
+     * 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) {
+                    // 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 = newLeftPos + "px";
+
+                        //set new top position
+                        var newTopPos = parseInt(centerTile.imgDiv.style.top)
+                          + deltaRow * newTileSize.h ;
+                        tile.imgDiv.style.top = newTopPos + "px";
+
+                        //set new width and height
+                        tile.imgDiv.style.width = newTileSize.w + "px";
+                        tile.imgDiv.style.height = 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 {OpenLayers.Size} newTileSize
+     * @param {float} newZoomlevel
+     * @param {float} newResolution
+     *
+     * @returns true if zoomOutTile is scaled, otherwise false
+     * @type Boolean
+     */
+    scaleZoomOutTile: function(newTileSize, newZoomlevel, newResolution) {
+        if (this.zoomOutTile) {
+            this.scaleZoomOutTile_share(newTileSize, 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
+     */
+    cloneLayerContainer:function() {
+        // share clone algorithm with other baselayers
+        this.cloneLayerContainer_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"

sandbox/emanuel/animatedZooming/lib/OpenLayers/Layer/Image.js

@@ -157 +157 @@
-    },
-        
+
+
+    /********************************************************/
+    /*                                                      */
+    /*       Baselayer Functions for zooming/scaling        */
+    /*                                                      */
+    /********************************************************/
+
+
+    /** 
+     * gets tile (image) size
+     *  
+     * @returns the image size
+     */
+    getTileSize:function() {
+        return this.tile.size;
+    },
+
+    /** 
+     * 
+     * @returns the only tile of the layer
+     * @type {OpenLayers.Tile}
+     */
+    getCenterTile:function() {   
+        return this.tile; 
+    },
+
+
-    /** @final @type String */
-    CLASS_NAME: "OpenLayers.Layer.Image"

sandbox/emanuel/animatedZooming/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 
@@ -92 +93 @@
-     * @type String
-     */
-
+
+
+
+
-        return this.getFullRequestString(
-                     {BBOX:bounds.toBBOX(),
-his.t
-his.t
+
+
-    },
-

sandbox/emanuel/animatedZooming/lib/OpenLayers/Layer/WMS/Untiled.js

@@ -32 +32 @@
-    tile: null,
-
-    /** did the image finish loading before a new draw was initiated?
-     * @type Boolean */
-    doneLoading: false,
-
-    /**
@@ -165 +162 @@
-            }
-
+            // fire loadstart event
-            this.events.triggerEvent("loadstart");
-            this.doneLoading = false;
-
+
+
-                this.tile = new OpenLayers.Tile.Image(this, pos, tileBounds, 
-                                                     url, tileSize);
-
+
+
-                var onload = function() { 
-                    this.doneLoading = true; 
-                    this.events.triggerEvent("loadend"); 
-                }
+ 
-                OpenLayers.Event.observe(this.tile.imgDiv, 'load',
-                                         onload.bindAsEventListener(this));
+
-            } else {
-                this.tile.moveTo(tileBounds, pos);
-            } 
-
-
-
-
-
-
-
-
+
+
+
+