Ticket #831: untiled.3.patch

tests/Tile/test_Image.html

@@ -25 +25 @@
-        t.ok( tile.size.equals(size), "tile.size is set correctly");
-    }
-    function test_02_Tile_Image_draw (t) {
-5
+7
-
-        var map = new OpenLayers.Map('map');
-        
@@ -40 +40 @@
-        var url = "http://www.openlayers.org/dev/tests/tileimage";
-        tile = new OpenLayers.Tile.Image(layer, position, bounds, url, size);
-        
+        tile.events.register("loadstart", this, function() { 
+            t.ok(true, "loadstart triggered");
+        });
+        tile.events.register("reload", this, function() { 
+            t.ok(true, "reload triggered");
+        });
+                
+        //this should trigger a "loadstart" event
-        tile.draw();
+        
-        var img = tile.imgDiv;
-        
-        if (!isMozilla)
@@ -63 +72 @@
-             "tile.draw creates an image");
-        t.eq( tile.imgDiv.style.width, "5px", "Image width is correct" );
-        t.eq( tile.imgDiv.style.height, "6px", "Image height is correct" );
+
+        // this should trigger a "reload" event (since the image never actually
+        // loads in tests)
+        tile.draw();
+        
-    }
-    function test_03_Tile_Image_OutsideMaxExtent(t) {
-        t.plan( 11 );

tests/test_Tile.html

@@ -5 +5 @@
-    var tile; 
-    
-    function test_01_Tile_constructor (t) {
-8
+9
-        
-        var layer = new Object(); // bogus layer
-        var position = new OpenLayers.Pixel(10,20);
@@ -24 +24 @@
-
-        t.ok( tile.id != null, "tile is given an id");
-        t.ok( tile.id.startsWith("Tile_"), "tile's id starts correctly");
+        t.ok( tile.events != null, "tile's events intitialized");
-    }
-
+    function test_99_Tile_destroy(t) {
+        t.plan( 6 );
+        
+        
+        var layer = new Object(); // bogus layer
+        var position = new OpenLayers.Pixel(10,20);
+        var bounds = new OpenLayers.Bounds(1,2,3,4);
+        var url = "bobob";
+        var size = new OpenLayers.Size(5,6);
+        
+        tile = new OpenLayers.Tile(layer, position, bounds, url, size);
+        tile.events.destroy = function() {
+            t.ok(true, "tile events destroy() called");
+        }
-
+ 
+        tile.destroy();
+
+        t.ok(tile.layer == null, "tile.layer set to null");
+        t.ok(tile.bounds == null, "tile.bounds set to null");
+        t.ok(tile.size == null, "tile.size set to null");
+        t.ok(tile.position == null, "tile.position set to null");
+        
+        t.ok(tile.events == null, "tile.events set to null");
+    }
+
+
-  // -->
-  </script>
-</head>

tests/Layer/test_Grid.html

@@ -23 +23 @@
-
-
-    function test_01_Layer_Grid_constructor (t) {
-1
+5
-                       
-        layer = new OpenLayers.Layer.Grid(name, url, params, null);
-        t.ok( layer instanceof OpenLayers.Layer.Grid, "returns OpenLayers.Layer.Grid object" );
+        t.eq( layer.buffer, 2, "buffer default is 2");
+        t.eq( layer.ratio, 1.5, "ratio default is 1.5");
+        t.eq( layer.numLoadingTiles, 0, "numLoadingTiles starts at 0");
+        t.ok( layer.events.listeners["tileloaded"] != null, "'tileloaded' event added to layer's event types");
+        
-    }
-
-
@@ -42 +47 @@
-    }
-
-    function test_03_Layer_Grid_clearTiles (t) {
-
+
+
-        var map = new OpenLayers.Map('map');
-        layer = new OpenLayers.Layer.WMS(name, url, params);
-        map.addLayer(layer);
-
-        map.setCenter(new OpenLayers.LonLat(0,0));
-
+        var numTiles = layer.grid.length * layer.grid[0].length;
-
-
-
+
+
+
+
+
+
+
+
+
-
+        OpenLayers.Tile.Image.prototype.destroy = function() {
+            if (!this.unhooked) {
+                allTilesUnhooked = false;
+            }
+            tilesDeleted++;
+        }
+
+        layer.removeTileMonitoringHooks = function(tile) {
+            tile.unhooked = true;            
+        }
+
-        layer.clearGrid();
-
-        t.ok( layer.grid != null, "layer.grid does not get nullified" );
+        t.eq(tilesDeleted, numTiles, "all tiles destroy()ed properly");
+        t.ok(allTilesUnhooked, "all tiles unhooked before being destroyed");
+
+        OpenLayers.Tile.Image.prototype.destroy =
+            OpenLayers.Tile.Image.prototype._destroy;
+        
-    }
-
-
-Grid
-1
+Tiles
+3
-
-        layer = new OpenLayers.Layer.WMS(name, url, params);
-
+
+    //normal grid
-        var bl = { bounds: new OpenLayers.Bounds(1,2,0,0)};
-        var tr = { bounds: new OpenLayers.Bounds(0,0,3,4)};
-        layer.grid = [ [6, tr], 
-                       [bl, 7]];
-
-
-
+
-        var testBounds = new OpenLayers.Bounds(1,2,3,4);
-        
-GridBounds() returns correct bounds")
+TilesBounds() returns correct bounds");
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
-    function test_05_Layer_Grid_getResolution(t) {
@@ -108 +153 @@
-
-        t.eq( zoom, 2, "getZoomForExtent() returns correct value");
-    }   
+    
+    function test_07_Layer_Grid_moveTo(t) {
-
+    t.plan(13);
-
+        var map = new OpenLayers.Map('map');
+        layer = new OpenLayers.Layer.WMS(name, url, params);
+        layer.destroy = function() {}; //we're going to do funky things with the grid
+        map.addLayer(layer);
+
+    //make sure null bounds doesnt cause script error. 
+    // no test necessary, just action
+        map.getExtent = function() { return null; }
+        layer.singleTile = false;
+        layer.moveTo(); //checks to make sure null bounds doesnt break us
+  
+
+
+      //observing globals
+        layer.initSingleTile = function(bounds) {
+            g_WhichFunc = "InitSingle";
+            g_Bounds = bounds;
+        };
+        layer.initGriddedTiles = function(bounds) {
+            g_WhichFunc = "InitGridded";
+            g_Bounds = bounds;
+        };
+        layer.moveGriddedTiles = function(bounds) {
+            g_WhichFunc = "MoveGridded";
+            g_Bounds = bounds;
+        };
+        var clearTestBounds = function() {
+            g_WhichFunc = null;
+            g_Bounds = null;
+        };
+
+      //default map extent (tested every time below)
+        b = new OpenLayers.Bounds(0,0,100,100);        
+        map.getExtent = function() {
+            return b;
+        };
+        var tilesBounds = null;
+        layer.getTilesBounds = function() {
+            return tilesBounds;
+        }
+
+
+//FORCE
+
+    //empty grid
+        layer.grid = new Array();
+       //grid
+        clearTestBounds();
+        layer.singleTile = false;
+        layer.moveTo()        
+        t.ok(g_Bounds.equals(b), "if grid is empty, initGridded called");
+        
+       //singletile
+        clearTestBounds();
+        layer.singleTile = true;
+        layer.moveTo()        
+        t.ok(g_Bounds.equals(b), "if grid is empty, initSingleTile called");
+
+    //zoomChanged
+        zoomChanged = true;
+        layer.grid = [ [ {} ] ];
+
+       //grid
+        clearTestBounds();
+        layer.singleTile = false;
+        layer.moveTo(null, zoomChanged);        
+        t.ok(g_Bounds.equals(b), "if layer has grid but zoomChanged is called, initGridded called");
+        
+       //singletile
+        clearTestBounds();
+        layer.singleTile = true;
+        layer.moveTo(null, zoomChanged);
+        t.ok(g_Bounds.equals(b), "if layer has grid but zoomChanged is called, initSingleTile called");
+
+
+        layer.getTilesBounds = function() {
+            return tilesBounds;
+        }
+        
+        
+
+//NO FORCE
+        zoomChanged = false;
+        layer.grid = [ [ {} ] ];
+ 
+   //single tile
+        layer.singleTile = true; 
+        
+      //DRAGGING   
+        var dragging = true;
+            
+        //in bounds
+        clearTestBounds();
+        tilesBounds = new OpenLayers.Bounds(-10,-10,110,110);
+        layer.moveTo(null, zoomChanged, dragging);
+        t.ok(g_Bounds == null, "if dragging and tile in bounds, no init()");
+        
+        //out bounds
+        clearTestBounds();
+        tilesBounds = new OpenLayers.Bounds(10,10,120,120);
+        layer.moveTo(null, zoomChanged, dragging);
+        t.ok(g_Bounds == null, "if dragging and tile out of bounds, no init()");
+
+      //NOT DRAGGING
+        dragging = false;
+
+        //in bounds
+        clearTestBounds();
+        tilesBounds = new OpenLayers.Bounds(-10,-10,110,110);
+        layer.moveTo(null, zoomChanged, dragging);
+        t.ok(g_Bounds == null, "if dragging and tile in bounds, no init()");
+        
+        //out bounds
+        clearTestBounds();
+        tilesBounds = new OpenLayers.Bounds(10,10,120,120);
+        layer.moveTo(null, zoomChanged, dragging);
+        t.ok(g_WhichFunc == "InitSingle", "if not dragging and tile out of bounds, we call initSingleTile()");
+        t.ok(g_Bounds.equals(b), "if not dragging and tile out of bounds, we call initSingleTile() with correct bounds");
+
+  
+   //gridded
+        layer.grid = [ [ {} ] ];
+        layer.singleTile = false;
+        
+        // drastic pan
+        clearTestBounds();
+        tilesBounds = new OpenLayers.Bounds(-150,-150,-120,-120);
+        layer.moveTo(null, zoomChanged);
+        t.ok(g_WhichFunc == "InitGridded", "if tiles drastically out of bounds, we call initGriddedTile()");
+        t.ok(g_Bounds.equals(b), "if tiles drastically out of bounds, we call initGriddedTile() with correct bounds");
+       
+        //regular move 
+        clearTestBounds();
+        tilesBounds = new OpenLayers.Bounds(10,10,120,120);
+        layer.moveTo(null, zoomChanged);
+        t.ok(g_WhichFunc == "MoveGridded", "if tiles not drastically out of bounds, we call moveGriddedTile()");
+        t.ok(g_Bounds.equals(b), "if tiles not drastically out of bounds, we call moveGriddedTile() with correct bounds");
+    }
+
-    /** THIS WOULD BE WHERE THE TESTS WOULD GO FOR 
-     *     
-     *    -moveTo
-     *    -insertColumn
-     *    -insertRow
-
-
-
+
-
-    function 08_Layer_Grid_insertColumn(t) {
-    }
@@ -155 +339 @@
-        layer.grid = null;
-    }
-
-
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+        var newTile = {
+            draw: function() {
+                t.ok(true, "newly created tile has been drawn");
+            }
+        };
+        layer.addTile = function(tileBounds, px) {
+            t.ok(tileBounds.equals(desiredTileBounds), "correct tile bounds passed to addTile to create new tile");
+            t.ok(px == translatedPX, "correct tile px passed to addTile to create new tile");
+            return newTile;
+        };
+        layer.addTileMonitoringHooks = function(tile) {
+            t.ok(tile == newTile, "adding monitoring hooks to the newly added tile");
+        };
+        layer.removeExcessTiles = function(x,y) {
+            t.ok(x == 1 && y == 1, "removeExcessTiles called")  
+        };
-
-
+
+
+
+
+
-        
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
+    
+    function test_15_Layer_Grid_removeTileMonitoringHooks(t) {
+        t.plan(2);
+        
+        layer = new OpenLayers.Layer.Grid();
+                
+        var tile = {
+            onLoadStart: {},
+            onLoadEnd: {},
+            events: {
+                unregister: function(name, obj, func) {
+                    g_unregistered[name] = [obj, func];
+                }
+            }
+        }
-
+        g_unregistered = {};
+        
+        layer.removeTileMonitoringHooks(tile);
+        
+        entry =  g_unregistered["loadstart"];
+        t.ok( entry && entry[0] == layer && entry[1] == tile.onLoadStart, "loadstart correctly unregistered");
-
+        entry =  g_unregistered["loadend"];
+        t.ok( entry && entry[0] == layer && entry[1] == tile.onLoadEnd, "loadend correctly unregistered");
+    }
+
-    function test_99_Layer_Grid_destroy (t) {
-
-        t.plan( 5 );

tests/Layer/test_KaMap.html

@@ -62 +62 @@
-        layer.grid = [ [6, tr], 
-                       [bl, 7]];
-
-Grid
+Tiles
-    
-        var testBounds = new OpenLayers.Bounds(1,2,3,4);
-        

tests/Layer/test_TMS.html

@@ -46 +46 @@
-        layer.grid = [ [6, tr], 
-                       [bl, 7]];
-
-Grid
+Tiles
-    
-        var testBounds = new OpenLayers.Bounds(1,2,3,4);
-        

lib/OpenLayers/Tile/Image.js

@@ -96 +96 @@
-        if (!OpenLayers.Tile.prototype.draw.apply(this, arguments)) {
-            return false;    
-        }
+        
+        if (this.isLoading) {
+            //if we're already loading, send 'reload' instead of 'loadstart'.
+            this.events.triggerEvent("reload"); 
+        } else {
+            this.isLoading = true;
+            this.events.triggerEvent("loadstart");
+        }
+        
-        if (this.imgDiv == null) {
-            this.initImgDiv();
-        }
@@ -202 +211 @@
-        // we need this reference to check back the viewRequestID
-        this.imgDiv.map = this.layer.map;
-
+        //bind a listener to the onload of the image div so that we 
+        // can register when a tile has finished loading.
+        var onload = function() {
+            
+            //normally isLoading should always be true here but there are some 
+            // right funky conditions where loading and then reloading a tile
+            // with the same url *really*fast*. this check prevents sending 
+            // a 'loadend' if the msg has already been sent
+            //
+            if (this.isLoading) { 
+                this.isLoading = false; 
+                this.events.triggerEvent("loadend"); 
+            }
+        }
+        OpenLayers.Event.observe(this.imgDiv, 'load',
+                                 onload.bindAsEventListener(this));
+
-    },
-
-    /**

lib/OpenLayers/Tile.js

@@ -21 +21 @@
-OpenLayers.Tile.prototype = {
-    
-    /** 
+     * Constant: EVENT_TYPES
+     * {Array(String)} Supported application event types
+     */
+    EVENT_TYPES: [ "loadstart", "loadend", "reload"],
+    
+    /**
+     * APIProperty: events
+     * {<OpenLayers.Events>} An events object that handles all 
+     *                       events on the tile.
+     */
+    events: null,
+
+    /**
-     * Property: id 
-     * {String} null
-     */
@@ -66 +79 @@
-     */
-    drawn: false,
-
+    /**
+     * Property: isLoading
+     * {Boolean} Is the tile loading?
+     */
+    isLoading: false,
+    
-    /** 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.
-     * 
@@ -88 +107 @@
-
-        //give the tile a unique id based on its BBOX.
-        this.id = OpenLayers.Util.createUniqueID("Tile_");
+        
+        this.events = new OpenLayers.Events(this, null, this.EVENT_TYPES);
-    },
-    
-    /** 
@@ -99 +120 @@
-        this.bounds = null;
-        this.size = null;
-        this.position = null;
+        
+        this.events.destroy();
+        this.events = null;
-    },
-
-    /**

lib/OpenLayers/Layer/Grid.js

@@ -29 +29 @@
-     */
-    grid: null,
-
+    /** APIProperty: ratio
+     *  {Float} Used only when in single-tile mode, this specifies the 
+     *          ratio of the size of the single tile to the size of the map.
+     */
+    ratio: 1.5,
+
-    /**
-     * APIProperty: buffer
-
+
+
+
-     */
-    buffer: 2,
-
-    /**
+     * APIProperty: numLoadingTiles
+     * {Integer} How many tiles are still loading?
+     */
+    numLoadingTiles: 0,
+
+    /**
-     * Constructor: OpenLayers.Layer.Grid
-     * Create a new grid layer
-     *
@@ -44 +58 @@
-     * url - {String}
-     * params - {Object}
-     * options - {Object} Hashtable of extra options to tag onto the layer
-
+ 
-    initialize: function(name, url, params, options) {
-        OpenLayers.Layer.HTTPRequest.prototype.initialize.apply(this, 
-                                                                arguments);
+        
+        //grid layers will trigger 'tileloaded' when each new tile is 
+        // loaded, as a means of progress update to listeners.
+        // listeners can access 'numLoadingTiles' if they wish to keep track
+        // of the loading progress
+        //
+        this.events.addEventType("tileloaded");
+
-        this.grid = new Array();
-    },
-
@@ -72 +94 @@
-            for(var iRow=0; iRow < this.grid.length; iRow++) {
-                var row = this.grid[iRow];
-                for(var iCol=0; iCol < row.length; iCol++) {
-
+
+
+
-                }
-            }
-            this.grid = [];
@@ -113 +137 @@
-    },    
-
-    /**
-     * Method: setMap
-     * When the layer is added to a map, then we can ask the map for
-     *   its default tile size
-     *
-     * Parameters:
-     * map - {<OpenLayers.Map>}
-     */
-    setMap: function(map) {
-        OpenLayers.Layer.HTTPRequest.prototype.setMap.apply(this, arguments);
-        if (this.tileSize == null) {
-            this.tileSize = this.map.getTileSize();
-        }
-    },
-
-    /**
-     * Method: moveTo
-     * This function is called whenever the map is moved. All the moving
-     * of actual 'tiles' is done by the map, but moveTo's role is to accept
@@ -141 +150 @@
-    moveTo:function(bounds, zoomChanged, dragging) {
-        OpenLayers.Layer.HTTPRequest.prototype.moveTo.apply(this, arguments);
-        
-
-
-
+
+
-        if (bounds != null) {
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            } else {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-                }
-            }
-        }
-    },
-    
-    /**
+     * APIMethod: setTileSize
+     * Check if we are in singleTile mode and if so, set the size as a ratio
+     *     of the map size (as specified by the layer's 'ratio' property).
+     * 
+     * Parameters:
+     * size - {<OpenLayers.Size>}
+     */
+    setTileSize: function(size) { 
+        if (this.singleTile) {
+            var size = this.map.getSize().clone();
+            size.h = size.h * this.ratio;
+            size.w = size.w * this.ratio;
+        } 
+        OpenLayers.Layer.HTTPRequest.prototype.setTileSize.apply(this, [size]);
+    },
+        
+    /**
-     * Method: getGridBounds
+     * Deprecated. This function will be removed in 3.0. Please use 
+     *     getTilesBounds() instead.
+     * 
+     * Return:
+     * {<OpenLayers.Bounds>} A Bounds object representing the bounds of all the
+     * currently loaded tiles (including those partially or not at all seen 
+     * onscreen)
+     */
+    getGridBounds: function() {
+        var msg = "The getGridBounds() function is deprecated. It will be " +
+                  "removed in 3.0. Please use getTilesBounds() instead.";
+        OpenLayers.Console.warn(msg);
+        return getTilesBounds();
+    },
+
+    /**
+     * Method: getTilesBounds
-     * Get the bounds of the grid
-     * 
-     * Return:
@@ -190 +229 @@
-     * currently loaded tiles (including those partially or not at all seen 
-     * onscreen)
-     */
-
+
+
-        
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
+
+
+
+
+
+
+
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    },
-
-    /**
-
-
+
+
+
+
-     */
-_initTiles:function(
- 
+initGriddedTiles:function(bounds
+
-        // work out mininum number of rows and columns; this is the number of
-        // tiles required to cover the viewport plus one for panning
-        var viewSize = this.map.getSize();
-        var minRows = Math.ceil(viewSize.h/this.tileSize.h) + 1;
-        var minCols = Math.ceil(viewSize.w/this.tileSize.w) + 1;
-        
-        var bounds = this.map.getExtent();
-        var extent = this.map.getMaxExtent();
-        var resolution = this.map.getResolution();
-        var tilelon = resolution * this.tileSize.w;
@@ -256 +342 @@
-            var colidx = 0;
- 
-            do {
-
-
-
-
+
+
+
+
+
-
-                var x = tileoffsetx;
-                x -= parseInt(this.map.layerContainerDiv.style.left);
@@ -271 +358 @@
-                var tile = row[colidx++];
-                if (!tile) {
-                    tile = this.addTile(tileBounds, px);
+                    this.addTileMonitoringHooks(tile);
-                    row.push(tile);
-                } else {
-                    tile.moveTo(tileBounds, px, false);
@@ -286 +374 @@
-        } while((tileoffsetlat >= bounds.bottom - tilelat * this.buffer)
-                || rowidx < minRows)
-        
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+