b6df3d871b
The reason is that we want to avoid moveGriddedTiles to run through hundreds of cycles to shift tiles until we reach the new bounds. But containsBounds does not work if extents that cross the date line start on different worlds, so we use intersectsBounds where we can pass the world bounds to handle this case.
1195 lines
39 KiB
HTML
1195 lines
39 KiB
HTML
<html>
|
|
<head>
|
|
<script src="../OLLoader.js"></script>
|
|
<script type="text/javascript">
|
|
var isMozilla = (navigator.userAgent.indexOf("compatible") == -1);
|
|
var layer;
|
|
|
|
var name = 'Test Layer';
|
|
var url = "http://vmap0.tiles.osgeo.org/wms/vmap0";
|
|
var params = {layers: 'basic', format: 'image/png'};
|
|
|
|
/**
|
|
* NOTE TO READER:
|
|
*
|
|
* Some of the tests on the Grid class actually use the WMS class.
|
|
* This is because WMS is a subclass of Grid and it implements the
|
|
* core functions which are necessary to test the tile-generation
|
|
* mechanism.
|
|
*
|
|
*/
|
|
|
|
|
|
function test_Layer_Grid_constructor (t) {
|
|
t.plan( 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, 0, "buffer default is 0");
|
|
t.eq( layer.ratio, 1.5, "ratio default is 1.5");
|
|
t.eq( layer.numLoadingTiles, 0, "numLoadingTiles starts at 0");
|
|
|
|
var obj = {};
|
|
var func = function() {};
|
|
layer.events.register('tileloaded', obj, func);
|
|
|
|
t.ok( layer.events.listeners['tileloaded'].length == 1, "one listener for tileloaded after register");
|
|
}
|
|
|
|
|
|
function test_Layer_Grid_inittiles (t) {
|
|
t.plan( 2 );
|
|
var map = new OpenLayers.Map('map');
|
|
layer = new OpenLayers.Layer.WMS(name, url, params, {buffer:2});
|
|
map.addLayer(layer);
|
|
map.setCenter(new OpenLayers.LonLat(0,0),5);
|
|
t.eq( layer.grid.length, 7, "Grid rows is correct." );
|
|
t.eq( layer.grid[0].length, 6, "Grid cols is correct." );
|
|
|
|
}
|
|
|
|
function test_Layer_Grid_clearTiles (t) {
|
|
t.plan(4);
|
|
|
|
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;
|
|
|
|
//our count of how many times tile.destroy() is called
|
|
tilesDeleted = 0;
|
|
|
|
//this will get set to false if we try to destroy a tile that has
|
|
// not been unhookedv
|
|
allTilesUnhooked = true;
|
|
|
|
OpenLayers.Tile.Image.prototype._destroy =
|
|
OpenLayers.Tile.Image.prototype.destroy;
|
|
|
|
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");
|
|
t.eq(layer.gridResolution, null, "gridResolution set to null");
|
|
|
|
OpenLayers.Tile.Image.prototype.destroy =
|
|
OpenLayers.Tile.Image.prototype._destroy;
|
|
|
|
}
|
|
|
|
|
|
function test_Layer_Grid_getTilesBounds(t) {
|
|
t.plan(4);
|
|
|
|
layer = new OpenLayers.Layer.WMS(name, url, params);
|
|
|
|
|
|
//normal grid
|
|
var bl = { bounds: new OpenLayers.Bounds(1,2,2,3)};
|
|
var tr = { bounds: new OpenLayers.Bounds(2,3,3,4)};
|
|
layer.grid = [ [6, tr],
|
|
[bl, 7]];
|
|
|
|
var bounds = layer.getTilesBounds();
|
|
var testBounds = new OpenLayers.Bounds(1,2,3,4);
|
|
|
|
t.ok( bounds.equals(testBounds), "getTilesBounds() returns correct bounds");
|
|
|
|
//no tiles
|
|
layer.grid = [];
|
|
bounds = layer.getTilesBounds();
|
|
|
|
t.ok(bounds == null, "getTilesBounds() on a tile-less grid returns null");
|
|
|
|
|
|
//singleTile
|
|
var singleTile = { bounds: new OpenLayers.Bounds(1,2,3,4)};
|
|
layer.grid = [ [ singleTile ] ];
|
|
bounds = layer.getTilesBounds();
|
|
|
|
t.ok( bounds.equals(testBounds), "getTilesBounds() returns correct bounds");
|
|
|
|
//world wrapped around the dateline
|
|
var bl = { bounds: new OpenLayers.Bounds(0,-90,180,90)};
|
|
var tr = { bounds: new OpenLayers.Bounds(-180,-90,0,90)};
|
|
layer.grid = [[bl, tr]];
|
|
|
|
var bounds = layer.getTilesBounds();
|
|
var testBounds = new OpenLayers.Bounds(0,-90,360,90);
|
|
|
|
t.ok( bounds.equals(testBounds), "getTilesBounds() returns correct bounds");
|
|
|
|
}
|
|
|
|
function test_Layer_Grid_getResolution(t) {
|
|
t.plan( 1 );
|
|
|
|
var map = new OpenLayers.Map('map');
|
|
layer = new OpenLayers.Layer.WMS(name, url, params);
|
|
map.addLayer(layer);
|
|
|
|
map.zoom = 5;
|
|
|
|
t.eq( layer.getResolution(), 0.0439453125, "getResolution() returns correct value");
|
|
}
|
|
|
|
function test_Layer_Grid_getZoomForExtent(t) {
|
|
t.plan( 2 );
|
|
var bounds, zoom;
|
|
|
|
var map = new OpenLayers.Map('map');
|
|
layer = new OpenLayers.Layer.WMS(name, url, params);
|
|
map.addLayer(layer);
|
|
|
|
bounds = new OpenLayers.Bounds(10,10,12,12);
|
|
zoom = layer.getZoomForExtent(bounds);
|
|
|
|
t.eq( zoom, 8, "getZoomForExtent() returns correct value");
|
|
|
|
bounds = new OpenLayers.Bounds(10,10,100,100);
|
|
zoom = layer.getZoomForExtent(bounds);
|
|
|
|
t.eq( zoom, 2, "getZoomForExtent() returns correct value");
|
|
}
|
|
|
|
function test_Layer_Grid_moveTo(t) {
|
|
|
|
t.plan(14);
|
|
|
|
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
|
|
layer.applyBackBuffer = function() {}; // backbuffering isn't under test here
|
|
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() {
|
|
g_WhichFunc = "MoveGridded";
|
|
g_Bounds = layer.map.getExtent();
|
|
};
|
|
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 = [];
|
|
//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");
|
|
|
|
|
|
//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;
|
|
|
|
//regular move
|
|
clearTestBounds();
|
|
tilesBounds = new OpenLayers.Bounds(10,10,120,120);
|
|
g_WhichFunc = null;
|
|
layer.moveTo(null, zoomChanged);
|
|
t.eq(g_WhichFunc, null, "moveGriddedTiles is delayed - not called yet");
|
|
t.delay_call(0.2, function() {
|
|
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");
|
|
});
|
|
|
|
// 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");
|
|
|
|
}
|
|
|
|
/** THIS WOULD BE WHERE THE TESTS WOULD GO FOR
|
|
*
|
|
* -insertColumn
|
|
* -insertRow
|
|
*
|
|
|
|
function 08_Layer_Grid_insertColumn(t) {
|
|
}
|
|
|
|
function 09_Layer_Grid_insertRow(t) {
|
|
}
|
|
|
|
*
|
|
*/
|
|
|
|
function test_Layer_Grid_clone(t) {
|
|
t.plan(5);
|
|
|
|
var options = {tileSize: new OpenLayers.Size(500,50)};
|
|
var map = new OpenLayers.Map('map', options);
|
|
layer = new OpenLayers.Layer.Grid(name, url, params);
|
|
map.addLayer(layer);
|
|
|
|
layer.grid = [ [6, 7],
|
|
[8, 9]];
|
|
|
|
var clone = layer.clone();
|
|
|
|
t.ok( clone.grid != layer.grid, "clone does not copy grid");
|
|
t.ok( clone.grid.length == 0, "clone creates a new array instead");
|
|
|
|
t.ok( clone.tileSize.equals(layer.tileSize), "tileSize correctly cloned");
|
|
|
|
layer.tileSize.w += 40;
|
|
|
|
t.eq( clone.tileSize.w, 500, "changing layer.tileSize does not change clone.tileSize -- a fresh copy was made, not just copied reference");
|
|
|
|
t.eq( clone.alpha, layer.alpha, "alpha copied correctly");
|
|
|
|
layer.grid = null;
|
|
}
|
|
|
|
function test_Layer_Grid_setTileSize(t) {
|
|
t.plan(1);
|
|
|
|
OpenLayers.Layer.HTTPRequest.prototype._setTileSize =
|
|
OpenLayers.Layer.HTTPRequest.prototype.setTileSize;
|
|
|
|
OpenLayers.Layer.HTTPRequest.prototype.setTileSize = function(size) {
|
|
g_Size = size;
|
|
};
|
|
|
|
|
|
layer = new OpenLayers.Layer.Grid(name, url, params, {
|
|
singleTile: true
|
|
});
|
|
mapSize = new OpenLayers.Size(100,1000);
|
|
layer.map = {
|
|
getSize: function() { return mapSize; }
|
|
}
|
|
|
|
g_Size = null;
|
|
layer.setTileSize();
|
|
|
|
var idealSize = new OpenLayers.Size(150,1500);
|
|
t.ok( g_Size && g_Size.equals(idealSize), "correctly calculated tile size passed to superclass setTileSize() function");
|
|
|
|
OpenLayers.Layer.HTTPRequest.prototype.setTileSize =
|
|
OpenLayers.Layer.HTTPRequest.prototype._setTileSize;
|
|
}
|
|
|
|
function test_Layer_Grid_initSingleTile(t) {
|
|
t.plan( 11 );
|
|
|
|
layer = new OpenLayers.Layer.Grid(name, url, params, {
|
|
singleTile: true,
|
|
ratio: 2
|
|
});
|
|
|
|
var bounds = new OpenLayers.Bounds(-10,10,50,100);
|
|
|
|
var desiredTileBounds = new OpenLayers.Bounds(-40,-35,80,145);
|
|
var desiredUL = new OpenLayers.LonLat(-40,145);
|
|
|
|
translatedPX = {};
|
|
layer.map = {
|
|
getLayerPxFromLonLat: function(ul) {
|
|
t.ok(ul.equals(desiredUL), "correct ul passed to translation");
|
|
return translatedPX;
|
|
},
|
|
getResolution: function() {
|
|
}
|
|
}
|
|
|
|
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")
|
|
};
|
|
|
|
|
|
layer.grid = [];
|
|
layer.initSingleTile(bounds);
|
|
|
|
t.ok(layer.grid[0][0] == newTile, "grid's 0,0 is set to the newly created tile");
|
|
|
|
var tile = {
|
|
moveTo: function(tileBounds, px) {
|
|
t.ok(tileBounds.equals(desiredTileBounds), "correct tile bounds passed to tile.moveTo()");
|
|
t.ok(px == translatedPX, "correct tile px passed to tile.moveTo()");
|
|
}
|
|
};
|
|
layer.grid = [[ tile ]];
|
|
layer.initSingleTile(bounds);
|
|
|
|
}
|
|
|
|
function test_Layer_Grid_addTileMonitoringHooks(t) {
|
|
t.plan(14);
|
|
|
|
layer = new OpenLayers.Layer.Grid();
|
|
layer.events = {
|
|
'triggerEvent': function(str) {
|
|
g_events.push(str);
|
|
}
|
|
}
|
|
|
|
var tile = {
|
|
events: {
|
|
register: function(name, obj, func) {
|
|
g_registered[name] = [obj, func];
|
|
}
|
|
}
|
|
}
|
|
|
|
g_registered = {};
|
|
g_events = [];
|
|
|
|
layer.addTileMonitoringHooks(tile);
|
|
|
|
//loadstart
|
|
t.ok(tile.onLoadStart != null, "onLoadStart function created and added to tile");
|
|
entry = g_registered["loadstart"];
|
|
t.ok( entry && entry[0] == layer && entry[1] == tile.onLoadStart, "loadstart correctly registered");
|
|
|
|
layer.numLoadingTiles = 0;
|
|
g_events = [];
|
|
tile.onLoadStart.apply(layer);
|
|
|
|
t.eq(g_events[0], "loadstart", "loadstart event triggered when numLoadingTiles is 0");
|
|
t.eq(layer.numLoadingTiles, 1, "numLoadingTiles incremented");
|
|
|
|
g_events = [];
|
|
tile.onLoadStart.apply(layer);
|
|
t.eq(g_events.length, 0, "loadstart event not triggered when numLoadingTiles is not 0");
|
|
t.eq(layer.numLoadingTiles, 2, "numLoadingTiles incremented");
|
|
|
|
|
|
//loadend
|
|
t.ok(tile.onLoadEnd != null, "onLoadEnd function created and added to tile");
|
|
entry = g_registered["loadend"];
|
|
t.ok( entry && entry[0] == layer && entry[1] == tile.onLoadEnd, "loadend correctly registered");
|
|
|
|
layer.numLoadingTiles = 2;
|
|
g_events = [];
|
|
tile.onLoadEnd.apply(layer);
|
|
t.eq(g_events[0], "tileloaded", "tileloaded triggered when numLoadingTiles is > 0");
|
|
t.eq(g_events.length, 1, "loadend event not triggered when numLoadingTiles is > 0");
|
|
t.eq(layer.numLoadingTiles, 1, "numLoadingTiles decremented");
|
|
|
|
|
|
g_events = [];
|
|
layer.grid = [[{}]]; // to prevent error in updateBackBuffer
|
|
tile.onLoadEnd.apply(layer);
|
|
t.eq(g_events[0], "tileloaded", "tileloaded triggered when numLoadingTiles is 0");
|
|
t.eq(g_events[1], "loadend", "loadend event triggered when numLoadingTiles is 0");
|
|
t.eq(layer.numLoadingTiles, 0, "numLoadingTiles decremented");
|
|
}
|
|
|
|
function test_Layer_Grid_removeTileMonitoringHooks(t) {
|
|
t.plan(2);
|
|
|
|
layer = new OpenLayers.Layer.Grid();
|
|
|
|
var tile = {
|
|
onLoadStart: {},
|
|
onLoadEnd: {},
|
|
unload: function() {},
|
|
events: {
|
|
unregister: function(name, obj, func) {
|
|
g_unregistered[name] = [obj, func];
|
|
},
|
|
un: OpenLayers.Events.prototype.un
|
|
}
|
|
}
|
|
|
|
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_Layer_Grid_tileSizeIsInteger(t) {
|
|
t.plan(1);
|
|
|
|
var map = new OpenLayers.Map('map');
|
|
var layer = new OpenLayers.Layer.Grid(name, url, params, {
|
|
singleTile: true,
|
|
ratio: 1.5
|
|
});
|
|
map.addLayers([layer]);
|
|
|
|
width = layer.tileSize.w;
|
|
height = layer.tileSize.h;
|
|
t.ok(width == parseInt(width) && height == parseInt(height), "calculated tileSize width/height are integer values");
|
|
}
|
|
function test_Layer_Grid_getTileBounds(t) {
|
|
t.plan(2);
|
|
var map = new OpenLayers.Map("map2");
|
|
var url = "http://octo.metacarta.com/cgi-bin/mapserv";
|
|
layer = new OpenLayers.Layer.WMS(name, url, params);
|
|
|
|
var newParams = { layers: 'sooper',
|
|
chickpeas: 'image/png'};
|
|
|
|
map.addLayer(layer);
|
|
map.zoomToMaxExtent();
|
|
map.zoomIn();
|
|
var bounds = layer.getTileBounds(new OpenLayers.Pixel(200,200));
|
|
t.eq(bounds.toBBOX(), "-180,-90,0,90", "get tile bounds returns correct bounds");
|
|
map.pan(200,0, {animate:false});
|
|
var bounds = layer.getTileBounds(new OpenLayers.Pixel(200,200));
|
|
t.eq(bounds.toBBOX(), "0,-90,180,90", "get tile bounds returns correct bounds after pan");
|
|
}
|
|
|
|
function test_Layer_Grid_moveTo_buffer_calculation (t) {
|
|
t.plan(6);
|
|
|
|
var map = new OpenLayers.Map( 'map3' ); // odd map size
|
|
var layer0 = new OpenLayers.Layer.WMS( "0 buffer: OpenLayers WMS",
|
|
"http://labs.metacarta.com/wms/vmap0",
|
|
{layers: 'basic'}, {'buffer':0} );
|
|
map.addLayer(layer0);
|
|
|
|
var layer1 = new OpenLayers.Layer.WMS( "1 buffer: OpenLayers WMS",
|
|
"http://labs.metacarta.com/wms/vmap0",
|
|
{layers: 'basic'}, {'buffer':1} );
|
|
map.addLayer(layer1);
|
|
|
|
var layer2 = new OpenLayers.Layer.WMS( "2 buffer: OpenLayers WMS",
|
|
"http://labs.metacarta.com/wms/vmap0",
|
|
{layers: 'basic'}, {'buffer':2} );
|
|
map.addLayer(layer2);
|
|
|
|
map.setCenter(new OpenLayers.LonLat(0, 0), 4);
|
|
t.eq( layer0.grid.length, 3, "Grid rows with buffer:0" );
|
|
map.setBaseLayer(layer1);
|
|
t.eq( layer1.grid.length, 4, "Grid rows with buffer:1" );
|
|
map.setBaseLayer(layer2);
|
|
t.eq( layer2.grid.length, 6, "Grid rows with buffer:2" );
|
|
|
|
// zooming in on Greenland exercises the bug from pre-r4313
|
|
map.setCenter(new OpenLayers.LonLat(0, 90), 4);
|
|
t.eq( layer0.grid.length, 3, "Grid rows with buffer:0" );
|
|
map.setBaseLayer(layer1);
|
|
t.eq( layer1.grid.length, 4, "Grid rows with buffer:1" );
|
|
map.setBaseLayer(layer2);
|
|
t.eq( layer2.grid.length, 6, "Grid rows with buffer:2" );
|
|
}
|
|
|
|
function test_Layer_Grid_destroy (t) {
|
|
|
|
t.plan( 9 );
|
|
|
|
var map = new OpenLayers.Map('map');
|
|
layer = new OpenLayers.Layer.Grid(name, url, params);
|
|
map.addLayer(layer);
|
|
layer.destroy();
|
|
t.eq( layer.grid, null, "layer.grid is null after destroy" );
|
|
t.eq( layer.tileSize, null, "layer.tileSize is null after destroy" );
|
|
|
|
|
|
//test with tile creation
|
|
layer = new OpenLayers.Layer.WMS(name, url, params);
|
|
map.addLayer(layer);
|
|
|
|
map.setCenter(new OpenLayers.LonLat(0,0), 10);
|
|
map.setCenter(new OpenLayers.LonLat(1,1));
|
|
|
|
//grab a reference to one of the tiles
|
|
var tile = layer.grid[1][1];
|
|
t.eq( tile.imgDiv.className, "olTileImage", "Tile has an image" );
|
|
|
|
var removeBackBufferCalled = false;
|
|
layer.removeBackBuffer = function() {
|
|
removeBackBufferCalled = true;
|
|
};
|
|
|
|
layer.destroy();
|
|
t.eq( tile.imgDiv, null, "Tile destroyed" );
|
|
t.eq( layer.timerId, null, "Tile loading timeout cleared");
|
|
t.ok( layer.grid == null, "tiles appropriately destroyed")
|
|
t.ok( removeBackBufferCalled, "destroy calls removeBackBuffer");
|
|
|
|
// destroy after remove from map
|
|
layer = new OpenLayers.Layer.WMS(name, url, params);
|
|
map.addLayer(layer);
|
|
map.setCenter(new OpenLayers.LonLat(0,0), 10);
|
|
map.removeLayer(layer);
|
|
layer.destroy();
|
|
t.eq( layer.grid, null, "layer.grid is null after destroy" );
|
|
t.eq( layer.tileSize, null, "layer.tileSize is null after destroy" );
|
|
}
|
|
|
|
function test_getServerResolution(t) {
|
|
|
|
t.plan(4);
|
|
|
|
var layer = new OpenLayers.Layer.Grid('', '', {}, {});
|
|
var res;
|
|
|
|
res = layer.getServerResolution(1);
|
|
t.eq(res, 1, '[1] getServerResolution return value is correct');
|
|
|
|
layer.serverResolutions = [2, 1];
|
|
res = layer.getServerResolution(1);
|
|
t.eq(res, 1, '[2] getServerResolution return value is correct');
|
|
|
|
layer.serverResolutions = [2];
|
|
res = layer.getServerResolution(1);
|
|
t.eq(res, 2, '[3] getServerResolution return value is correct');
|
|
|
|
var exc;
|
|
layer.serverResolutions = [0.5];
|
|
try {
|
|
res = layer.getServerResolution(1);
|
|
} catch(e) {
|
|
exc = e;
|
|
}
|
|
t.ok(exc != undefined, '[4] getServerResolution generates exception');
|
|
}
|
|
|
|
function test_getServerZoom(t) {
|
|
|
|
t.plan(5);
|
|
|
|
var resolution, zoom;
|
|
var map = new OpenLayers.Map('map', {
|
|
resolutions: [8, 4, 2, 1, 0.5],
|
|
getResolution: function() {
|
|
return resolution;
|
|
}
|
|
});
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {isBaseLayer: true});
|
|
map.addLayer(layer);
|
|
|
|
resolution = 8;
|
|
zoom = layer.getServerZoom();
|
|
t.eq(zoom, 0, '[1] getServerZoom return value is correct');
|
|
|
|
resolution = 4;
|
|
zoom = layer.getServerZoom();
|
|
t.eq(zoom, 1, '[2] getServerZoom return value is correct');
|
|
|
|
layer.serverResolutions = [2, 1];
|
|
resolution = 1;
|
|
zoom = layer.getServerZoom();
|
|
t.eq(zoom, 3, '[3] getServerZoom return value is correct');
|
|
|
|
layer.serverResolutions = [2];
|
|
resolution = 0.5;
|
|
zoom = layer.getServerZoom();
|
|
t.eq(zoom, 2, '[4] getServerZoom return value is correct');
|
|
|
|
var exc;
|
|
layer.serverResolutions = [0.5];
|
|
resolution = 1;
|
|
try {
|
|
zoom = layer.getServerZoom();
|
|
} catch(e) {
|
|
exc = e;
|
|
}
|
|
t.ok(exc != undefined, '[4] getServerZoom generates exception');
|
|
|
|
map.destroy();
|
|
}
|
|
|
|
function test_moveTo_scale(t) {
|
|
|
|
t.plan(11);
|
|
|
|
var map = new OpenLayers.Map('map', {
|
|
resolutions: [32, 16, 8, 4, 2, 1]
|
|
});
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {
|
|
isBaseLayer: true,
|
|
serverResolutions: [32, 16, 8]
|
|
});
|
|
map.addLayer(layer);
|
|
|
|
// initial resolution is 8
|
|
map.setCenter(new OpenLayers.LonLat(0, 0), 2);
|
|
|
|
// test initial conditions
|
|
t.eq(layer.div.style.width, '100%', 'layer div scale is 1');
|
|
|
|
// change from resolution 8 to 4
|
|
map.zoomTo(3);
|
|
t.eq(layer.div.style.width, '200%', '[8->4] layer div scale is 2');
|
|
|
|
// change from resolution 8 to 2
|
|
map.zoomTo(2); map.zoomTo(4);
|
|
t.eq(layer.div.style.width, '400%', '[8->2] layer div scale is 4');
|
|
|
|
// change from resolution 8 to 1
|
|
map.zoomTo(2); map.zoomTo(5);
|
|
t.eq(layer.div.style.width, '800%', '[8->1] layer div scale is 8');
|
|
|
|
// change from resolution 4 to 2
|
|
map.zoomTo(3); map.zoomTo(4);
|
|
t.eq(layer.div.style.width, '400%', '[4->2] layer div scale is 4');
|
|
|
|
// change from resolution 4 to 1
|
|
map.zoomTo(3); map.zoomTo(5);
|
|
t.eq(layer.div.style.width, '800%', '[4->1] layer div scale is 8');
|
|
|
|
// change from resolution 2 to 1
|
|
map.zoomTo(4); map.zoomTo(5);
|
|
t.eq(layer.div.style.width, '800%', '[2->1] layer div scale is 8');
|
|
|
|
// change from resolution 1 to 2
|
|
map.zoomTo(5); map.zoomTo(4);
|
|
t.eq(layer.div.style.width, '400%', '[1->2] layer div scale is 4');
|
|
|
|
// change from resolution 1 to 4
|
|
map.zoomTo(5); map.zoomTo(3);
|
|
t.eq(layer.div.style.width, '200%', '[1->4] layer div scale is 2');
|
|
|
|
// change from resolution 1 to 8
|
|
map.zoomTo(5); map.zoomTo(2);
|
|
t.eq(layer.div.style.width, '100%', '[1->8] layer div scale is 1');
|
|
|
|
// change from resolution 1 to 16
|
|
map.zoomTo(5); map.zoomTo(1);
|
|
t.eq(layer.div.style.width, '100%', '[1->16] layer div scale is 1');
|
|
|
|
map.destroy();
|
|
}
|
|
|
|
function test_moveTo_backbuffer_singletile(t) {
|
|
t.plan(4);
|
|
|
|
var map = new OpenLayers.Map('map', {
|
|
resolutions: [1, 0.5, 0.025]
|
|
});
|
|
var resolution;
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {
|
|
singleTile: true,
|
|
isBaseLayer: true,
|
|
transitionEffect: 'resize',
|
|
applyBackBuffer: function(res) {
|
|
resolution = res;
|
|
}
|
|
});
|
|
map.addLayer(layer);
|
|
|
|
// initial resolution is 0.025
|
|
resolution = undefined;
|
|
map.setCenter(new OpenLayers.LonLat(0, 0), 2);
|
|
t.eq(resolution, 0.025,
|
|
'applyBackBuffer not called on first moveTo');
|
|
|
|
// move to (-90, 45)
|
|
resolution = undefined;
|
|
map.setCenter(new OpenLayers.LonLat(-90, 45));
|
|
t.eq(resolution, 0.025,
|
|
'applyBackBuffer called when map is moved');
|
|
|
|
// change to resolution 1
|
|
resolution = undefined;
|
|
map.zoomTo(0);
|
|
t.eq(resolution, 1,
|
|
'applyBackBuffer called when map is zoomed out');
|
|
|
|
// change to resolution 0.5
|
|
resolution = undefined;
|
|
map.zoomTo(1);
|
|
t.eq(resolution, 0.5,
|
|
'applyBackBuffer called when map is zoomed out');
|
|
|
|
map.destroy();
|
|
}
|
|
|
|
function test_moveTo_backbuffer(t) {
|
|
t.plan(4);
|
|
|
|
var map = new OpenLayers.Map('map', {
|
|
resolutions: [1, 0.5, 0.025]
|
|
});
|
|
var resolution;
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {
|
|
isBaseLayer: true,
|
|
transitionEffect: 'resize',
|
|
applyBackBuffer: function(res) {
|
|
resolution = res;
|
|
}
|
|
});
|
|
map.addLayer(layer);
|
|
|
|
// initial resolution is 0.025
|
|
resolution = undefined;
|
|
map.setCenter(new OpenLayers.LonLat(0, 0), 2);
|
|
t.eq(resolution, 0.025,
|
|
'applyBackBuffer not called on first moveTo');
|
|
|
|
// move to (-90, 45)
|
|
resolution = undefined;
|
|
map.setCenter(new OpenLayers.LonLat(-90, 45));
|
|
t.eq(resolution, undefined,
|
|
'applyBackBuffer not called when map is moved');
|
|
|
|
// change to resolution 1
|
|
resolution = undefined;
|
|
map.zoomTo(0);
|
|
t.eq(resolution, 1,
|
|
'applyBackBuffer called when map is zoomed out');
|
|
|
|
// change to resolution 0.5
|
|
map.zoomTo(1);
|
|
t.eq(resolution, 0.5,
|
|
'applyBackBuffer called when map is zoomed out');
|
|
|
|
map.destroy();
|
|
}
|
|
|
|
function test_transformDiv(t) {
|
|
|
|
t.plan(8);
|
|
|
|
var map = new OpenLayers.Map('map4');
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {
|
|
isBaseLayer: true
|
|
});
|
|
map.addLayer(layer);
|
|
map.zoomToMaxExtent();
|
|
|
|
// the layer container's dimensions are 100px width 100px height
|
|
// the position of the viewport center is 384, 256
|
|
|
|
layer.transformDiv(2);
|
|
|
|
t.eq(layer.div.style.width, '200%', '[1] layer div has correct width');
|
|
t.eq(layer.div.style.height, '200%', '[1] layer div has correct height');
|
|
|
|
t.eq(layer.div.style.left, '-384%', '[1] layer div has correct left');
|
|
t.eq(layer.div.style.top, '-256%', '[1] layer div has correct top');
|
|
|
|
// now move the layer container and test again
|
|
|
|
map.layerContainerDiv.style.left = '-1024px';
|
|
map.layerContainerDiv.style.top = '768px';
|
|
|
|
layer.transformDiv(2);
|
|
|
|
t.eq(layer.div.style.width, '200%', '[2] layer div has correct width');
|
|
t.eq(layer.div.style.height, '200%', '[2] layer div has correct height');
|
|
|
|
t.eq(layer.div.style.left, '-1408%', '[2] layer div has correct left');
|
|
t.eq(layer.div.style.top, '512%', '[2] layer div has correct top');
|
|
|
|
map.destroy();
|
|
}
|
|
|
|
function test_getResolutionScale(t) {
|
|
t.plan(1);
|
|
|
|
var map = new OpenLayers.Map('map');
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {
|
|
isBaseLayer: true
|
|
});
|
|
map.addLayer(layer);
|
|
map.zoomToMaxExtent();
|
|
|
|
layer.transformDiv(2);
|
|
var scale = layer.getResolutionScale();
|
|
t.eq(scale, 2, 'getResolutionScale returns correct value');
|
|
|
|
map.destroy();
|
|
}
|
|
|
|
function test_applyBackBuffer(t) {
|
|
t.plan(13);
|
|
|
|
var map = new OpenLayers.Map('map2');
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {
|
|
isBaseLayer: true
|
|
});
|
|
map.addLayer(layer);
|
|
map.zoomToMaxExtent();
|
|
|
|
var backBuffer;
|
|
|
|
// test #1
|
|
layer.createBackBuffer = function() {
|
|
return;
|
|
};
|
|
layer.applyBackBuffer(2);
|
|
t.eq(layer.backBuffer, undefined,
|
|
'back buffer not created if createBackBuffer returns undefined');
|
|
|
|
// test #2
|
|
layer.createBackBuffer = function() {
|
|
backBuffer = document.createElement('div');
|
|
return backBuffer;
|
|
};
|
|
layer.gridResolution = 32;
|
|
layer.grid[0][0].bounds = new OpenLayers.Bounds(0, 1, 1, 0);
|
|
layer.applyBackBuffer(2);
|
|
t.ok(layer.backBuffer === backBuffer,
|
|
'back buffer set in layer');
|
|
t.ok(layer.div.firstChild === backBuffer,
|
|
'back buffer inserted as first child');
|
|
t.eq(layer.backBuffer.style.width, '1600%',
|
|
'back buffer has correct width');
|
|
t.eq(layer.backBuffer.style.height, '1600%',
|
|
'back buffer has correct height');
|
|
t.eq(layer.backBuffer.style.left, '250%',
|
|
'back buffer has correct left');
|
|
t.eq(layer.backBuffer.style.top, '275%',
|
|
'back buffer has correct top');
|
|
|
|
// test #3
|
|
layer.createBackBuffer = function() {
|
|
backBuffer = document.createElement('div');
|
|
return backBuffer;
|
|
};
|
|
layer.gridResolution = 32;
|
|
layer.grid[0][0].bounds = new OpenLayers.Bounds(0, 1, 1, 0);
|
|
map.layerContainerDiv.style.left = '20px';
|
|
map.layerContainerDiv.style.top = '-20px';
|
|
layer.applyBackBuffer(2);
|
|
t.ok(layer.backBuffer === backBuffer,
|
|
'back buffer set in layer');
|
|
t.ok(layer.div.firstChild === backBuffer,
|
|
'back buffer inserted as first child');
|
|
t.eq(layer.backBuffer.style.width, '1600%',
|
|
'back buffer has correct width');
|
|
t.eq(layer.backBuffer.style.height, '1600%',
|
|
'back buffer has correct height');
|
|
t.eq(layer.backBuffer.style.left, '230%',
|
|
'back buffer has correct left');
|
|
t.eq(layer.backBuffer.style.top, '295%',
|
|
'back buffer has correct top');
|
|
|
|
map.destroy();
|
|
}
|
|
|
|
function test_createBackBuffer(t) {
|
|
t.plan(7);
|
|
|
|
var map = new OpenLayers.Map('map');
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {
|
|
isBaseLayer: true
|
|
});
|
|
map.addLayer(layer);
|
|
map.zoomToMaxExtent();
|
|
|
|
var createBackBuffer = OpenLayers.Tile.Image.prototype.createBackBuffer;
|
|
|
|
var backBuffer;
|
|
|
|
OpenLayers.Tile.Image.prototype.createBackBuffer = function() {
|
|
return;
|
|
};
|
|
backBuffer = layer.createBackBuffer();
|
|
t.ok(backBuffer != undefined,
|
|
'createBackBuffer returns a back buffer');
|
|
t.eq(backBuffer.childNodes.length, 0,
|
|
'returned back buffer has no child nodes');
|
|
|
|
OpenLayers.Tile.Image.prototype.createBackBuffer = function() {
|
|
return document.createElement('div');
|
|
};
|
|
backBuffer = layer.createBackBuffer();
|
|
t.ok(backBuffer != undefined,
|
|
'createBackBuffer returns a back buffer');
|
|
t.eq(backBuffer.childNodes[0].style.left, '0%',
|
|
'first tile has correct left');
|
|
t.eq(backBuffer.childNodes[0].style.top, '0%',
|
|
'first tile has correct top');
|
|
t.eq(backBuffer.childNodes[1].style.left, '256%',
|
|
'second tile has correct left');
|
|
t.eq(backBuffer.childNodes[1].style.top, '0%',
|
|
'second tile has correct top');
|
|
|
|
map.destroy();
|
|
OpenLayers.Tile.Image.prototype.createBackBuffer = createBackBuffer;
|
|
}
|
|
|
|
function test_removeBackBuffer(t) {
|
|
t.plan(3);
|
|
|
|
var map = new OpenLayers.Map('map');
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {isBaseLayer: true});
|
|
map.addLayer(layer);
|
|
|
|
// add a fake back buffer
|
|
var backBuffer = document.createElement('div');
|
|
layer.backBuffer = backBuffer;
|
|
layer.div.appendChild(backBuffer);
|
|
layer.backBufferResolution = 32;
|
|
|
|
layer.removeBackBuffer();
|
|
t.eq(layer.backBuffer, null, 'backBuffer set to null in layer');
|
|
t.eq(layer.backBufferResolution, null,
|
|
'backBufferResolution set to null in layer');
|
|
t.ok(backBuffer.parentNode !== layer.div,
|
|
'back buffer removed from layer');
|
|
|
|
map.destroy();
|
|
}
|
|
|
|
function test_singleTile_move_and_zoom(t) {
|
|
|
|
//
|
|
// In single tile mode with no transition effect, we insert a non-scaled
|
|
// backbuffer when the layer is moved. But if a zoom occurs right after
|
|
// a move, i.e. before the new image is received, we need to remove the
|
|
// backbuffer, or an ill-positioned image will be visible during the
|
|
// zoom transition.
|
|
//
|
|
|
|
t.plan(2);
|
|
|
|
var map = new OpenLayers.Map('map');
|
|
var layer = new OpenLayers.Layer.WMS('', '', {}, {
|
|
isBaseLayer: true,
|
|
singleTile: true,
|
|
ratio: 1
|
|
});
|
|
map.addLayer(layer);
|
|
map.setCenter(new OpenLayers.LonLat(0, 0), 0);
|
|
|
|
// move
|
|
map.setCenter(new OpenLayers.LonLat(10, 10));
|
|
t.ok(layer.backBuffer && layer.backBuffer.parentNode === layer.div,
|
|
'backbuffer inserted after map move');
|
|
|
|
// zoom
|
|
map.zoomTo(1);
|
|
t.eq(layer.backBuffer, null,
|
|
'back buffer removed when zooming');
|
|
|
|
map.destroy();
|
|
}
|
|
|
|
function test_backbuffer_scaled_layer(t) {
|
|
t.plan(12);
|
|
|
|
//
|
|
// set up
|
|
//
|
|
|
|
var map = new OpenLayers.Map('map', {
|
|
resolutions: [32, 16, 8, 4, 2, 1]
|
|
});
|
|
var layer = new OpenLayers.Layer.WMS(
|
|
"WMS",
|
|
window.location.href + "#",
|
|
null,
|
|
{transitionEffect: "resize"}
|
|
);
|
|
|
|
layer.serverResolutions = [32, 16, 8];
|
|
|
|
map.addLayer(layer);
|
|
map.setCenter(new OpenLayers.LonLat(0, 0), 2);
|
|
|
|
layer.createBackBuffer = function() {
|
|
return document.createElement('div');
|
|
};
|
|
|
|
// we want to control when the back buffer is removed
|
|
var removeBackBuffer = OpenLayers.Function.bind(
|
|
layer.removeBackBuffer, layer);
|
|
layer.removeBackBuffer = function() {};
|
|
|
|
//
|
|
// test
|
|
//
|
|
|
|
// change resolution from 8 to 4
|
|
map.zoomTo(3);
|
|
t.eq(layer.backBuffer.style.width, '100%',
|
|
'[8->4] back buffer not scaled');
|
|
removeBackBuffer();
|
|
|
|
// change resolution from 8 to 2
|
|
map.zoomTo(2); removeBackBuffer(); map.zoomTo(4);
|
|
t.eq(layer.backBuffer.style.width, '100%',
|
|
'[8->2] back buffer not scaled');
|
|
removeBackBuffer();
|
|
|
|
// change resolution from 16 to 4
|
|
map.zoomTo(1); removeBackBuffer(); map.zoomTo(3);
|
|
t.eq(layer.backBuffer.style.width, '200%',
|
|
'[16->4] back buffer width is as expected');
|
|
t.eq(layer.backBuffer.style.width, '200%',
|
|
'[16->4] back buffer height is as expected');
|
|
removeBackBuffer();
|
|
|
|
// change resolution from 32 to 1
|
|
map.zoomTo(0); removeBackBuffer(); map.zoomTo(5);
|
|
t.eq(layer.backBuffer.style.width, '400%',
|
|
'[32->1] back buffer width is as expected');
|
|
t.eq(layer.backBuffer.style.width, '400%',
|
|
'[32->1] back buffer height is as expected');
|
|
removeBackBuffer();
|
|
|
|
// change resolution from 4 to 2
|
|
map.zoomTo(3); removeBackBuffer(); map.zoomTo(4);
|
|
t.eq(layer.backBuffer.style.width, '100%',
|
|
'[4->2] back buffer not scaled');
|
|
removeBackBuffer();
|
|
|
|
// change resolution from 4 to 1
|
|
map.zoomTo(3); removeBackBuffer(); map.zoomTo(5);
|
|
t.eq(layer.backBuffer.style.width, '100%',
|
|
'[4->1] back buffer not scaled');
|
|
removeBackBuffer();
|
|
|
|
// change resolution from 1 to 4
|
|
map.zoomTo(5); removeBackBuffer(); map.zoomTo(3);
|
|
t.eq(layer.backBuffer.style.width, '100%',
|
|
'[1->4] back buffer not scaled');
|
|
removeBackBuffer();
|
|
|
|
// change resolution from 4 to 8
|
|
map.zoomTo(3); removeBackBuffer(); map.zoomTo(2);
|
|
t.eq(layer.backBuffer.style.width, '100%',
|
|
'[4->8] back buffer not scaled');
|
|
removeBackBuffer();
|
|
|
|
// change resolution from 4 to 16
|
|
map.zoomTo(3); removeBackBuffer(); map.zoomTo(1);
|
|
t.eq(layer.backBuffer.style.width, '50%',
|
|
'[4->16] back buffer width is as expected');
|
|
t.eq(layer.backBuffer.style.width, '50%',
|
|
'[4->16] back buffer height is as expected');
|
|
removeBackBuffer();
|
|
|
|
//
|
|
// tear down
|
|
//
|
|
|
|
map.destroy();
|
|
}
|
|
</script>
|
|
</head>
|
|
<body>
|
|
<div id="map" style="width:499px;height:549px;display:none"></div>
|
|
<div id="map2" style="width:500px;height:550px;display:none"></div>
|
|
<div id="map3" style="width:594px;height:464px;display:none"></div>
|
|
<div id="map4" style="width:768px;height:512px;display:none"></div>
|
|
</body>
|
|
</html>
|