Ticket #933: resize_transition.patch

lib/OpenLayers/Tile/Image.js

@@ -146 +146 @@
-            this.events.triggerEvent("loadstart");
-        }
-        
+        return this.renderTile();
+    },
+    
+    /**
+     * Method: renderTile
+     *
+     * internal function to actually initialize the image tile,
+     * position it correctly, and set its url
+     */
+    renderTile: function() {
-        if (this.imgDiv == null) {
-            this.initImgDiv();
-        }
@@ -162 +172 @@
-            OpenLayers.Util.modifyAlphaImageDiv(this.imgDiv,
-                    null, null, imageSize, this.url);
-        } else {
-            this.imgDiv.src = this.url;
-            OpenLayers.Util.modifyDOMElement(this.imgDiv,
-                    null, null, imageSize) ;
+            this.imgDiv.src = this.url;
-        }
-        return true;
-    },
@@ -176 +186 @@
-     */
-    clear: function() {
-        if(this.imgDiv) {
-imgDiv.style.display = "none"
+hide()
-            if (OpenLayers.Tile.Image.useBlankTile) { 
-                this.imgDiv.src = OpenLayers.Util.getImagesLocation() + "blank.gif";
-            }    
@@ -223 +233 @@
-        OpenLayers.Event.observe( this.imgDiv, "load",
-            OpenLayers.Function.bind(this.checkImgURL, this) );
-        */
+        this.frame.style.zIndex = this.isBackBuffer ? 0 : 1;
-        this.frame.appendChild(this.imgDiv); 
-        this.layer.div.appendChild(this.frame); 
-
@@ -300 +311 @@
-        if (this.layer) {
-            var loaded = this.layerAlphaHack ? this.imgDiv.firstChild.src : this.imgDiv.src;
-            if (!OpenLayers.Util.isEquivalentUrl(loaded, this.url)) {
-imgDiv.style.display = "none"
+hide()
-            }
-        }
-    },
+    
+    /**
+     * Method: startTransition
+     *
+     * This method is invoked on tiles that are backBuffers for tiles in the
+     * grid.  The grid tile is about to be cleared and a new tile source
+     * loaded.  This is where the transition effect needs to be started
+     * to provide visual continuity.
+     */
+    startTransition: function() {
+        // backBufferTile has to be valid and ready to use
+        if (!this.backBufferTile || !this.backBufferTile.imgDiv) {
+            return;
+        }
-
+        // show the backBufferTile and hide this tile
+        this.hide();
+
+        // calculate the ratio of change between the current resolution of the
+        // backBufferTile and the layer.  If several animations happen in a
+        // row, then the backBufferTile will scale itself appropriately for
+        // each request.
+        var ratio = 1;
+        if (this.backBufferTile.resolution) {
+            ratio = this.backBufferTile.resolution / this.layer.getResolution() ;
+        }
+        
+        // if the ratio is not 1 (i.e. we are zooming), then we might be 
+        // resizing the backBuffer tile ...
+        if (ratio != 1) {
+            if (this.layer.transitionEffect == 'resize') {
+                // In this case, we can just immediately resize the 
+                // backBufferTile.
+                var upperLeft = 
+                    new OpenLayers.LonLat(this.backBufferTile.bounds.left, 
+                                          this.backBufferTile.bounds.top);
+                var size = 
+                    new OpenLayers.Size(this.backBufferTile.size.w * ratio, 
+                                        this.backBufferTile.size.h * ratio);
+
+                var px = this.layer.map.getLayerPxFromLonLat(upperLeft);
+                OpenLayers.Util.modifyDOMElement(this.backBufferTile.frame, 
+                                                 null, px, size);   
+                var imageSize = this.backBufferTile.size.clone();
+                imageSize = new OpenLayers.Size(imageSize.w * ratio, 
+                                                imageSize.h * ratio);
+
+                OpenLayers.Util.modifyDOMElement(this.backBufferTile.imgDiv,
+                                                 null, null, imageSize) ;
+
+                this.backBufferTile.show();
+            }
+        } else {
+            // default effect is just to leave the existing tile
+            // until the new one loads if this is a singleTile and
+            // there was no change in resolution.  Otherwise we
+            // don't bother to show the backBufferTile at all
+            if (this.layer.singleTile && ratio == 1) {
+                this.backBufferTile.show();
+            } else {
+                this.backBufferTile.hide();
+            }
+        }
+    },
+    
+    /** 
+     * Method: show
+     *
+     * show the tile by showing its frame.
+     */
+    show: function() {
+        this.frame.style.display = '';
+    },
+    
+    /** 
+     * Method: hide
+     *
+     * hide the tile by hiding its frame.
+     */
+    hide: function() {
+        this.frame.style.display = 'none';
+    },
+    
-    CLASS_NAME: "OpenLayers.Tile.Image"
-  }
-);

lib/OpenLayers/Tile.js

@@ -80 +80 @@
-     */
-    isLoading: false,
-    
+    /**
+     * Property: isBackBuffer
+     * {Boolean} Is this tile a back buffer tile?
+     */
+    isBackBuffer: false,
+    
+    /**
+     * Property: isFirstDraw
+     * {Boolean} Is this the first time the tile is being drawn?
+     * This is used to force resetBackBuffer to synchronize
+     * the backBufferTile with the foreground tile the first time
+     * the foreground tile loads so that if the user zooms
+     * before the layer has fully loaded, the backBufferTile for
+     * tiles that have been loaded can be used.
+     */
+    isFirstDraw: true,
+        
+    /**
+     * Property: backBufferTile
+     * {<OpenLayers.Tile>} A clone of the tile used to create transition
+     * effects when the tile is moved or changes resolution.
+     */
+    backBufferTile: null,
+        
-    /** TBD 3.0 -- remove 'url' from the list of parameters to the constructor.
-     *             there is no need for the base tile class to have a url.
-     * 
@@ -111 +135 @@
-     * Nullify references to prevent circular references and memory leaks.
-     */
-    destroy:function() {
+        this.layer.events.unregister("loadend", this, this.resetBackBuffer);
+        this.events.unregister('loadend', this, this.resetBackBuffer);
-        this.layer  = null;
-        this.bounds = null;
-        this.size = null;
@@ -118 +144 @@
-        
-        this.events.destroy();
-        this.events = null;
+        
+        /* clean up the backBufferTile if it exists */
+        if (this.backBufferTile) {
+            this.backBufferTile.destroy();
+            this.backBufferTile = null;
+        }
-    },
-    
-    /**
@@ -157 +189 @@
-     */
-    draw: function() {
-        
-        //clear tile's contents and mark as not drawn
-        this.clear();
-        
-        var maxExtent = this.layer.maxExtent;
-        var withinMaxExtent = (maxExtent &&
-                               this.bounds.intersectsBounds(maxExtent, false));
- 
-        // The only case where we *wouldn't* want to draw the tile is if the 
-        // tile is outside its layer's maxExtent.
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    },
-    
-    /** 
@@ -240 +305 @@
-                                       topLeft.lat);  
-        return bounds;
-    },        
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    CLASS_NAME: "OpenLayers.Tile"
-});

lib/OpenLayers/Layer.js

@@ -231 +231 @@
-     */
-    wrapDateLine: false,
-    
+    /**
+     * APIProperty: transitionEffect
+     * {String} The transition effect to use when the map is panned or
+     * zoomed.  There is currently two supported values:
+     * null - no transition effect (the default).
+     * resize - existing tiles are resized on zoom to provide a visual
+     *   effect of the zoom having taken place immediately.  As the
+     *   new tiles become available, they are drawn over top of the
+     *    resized tiles.
+     */
+    transitionEffect: null,
-    
-    /**
-     * Constructor: OpenLayers.Layer