Base class for layers that use a lattice of tiles. Create a new grid layer with the OpenLayers.Layer.Grid constructor.
| OpenLayers. | Base class for layers that use a lattice of tiles. |
| Properties | |
| tileSize | {OpenLayers.Size} |
| tileOriginCorner | {String} If the tileOrigin property is not provided, the tile origin will be derived from the layer’s maxExtent. |
| tileOrigin | {OpenLayers.LonLat} Optional origin for aligning the grid of tiles. |
| tileOptions | {Object} optional configuration options for OpenLayers.Tile instances created by this Layer, if supported by the tile class. |
| tileClass | {OpenLayers.Tile} The tile class to use for this layer. |
| grid | {Array(Array(OpenLayers.Tile))} This is an array of rows, each row is an array of tiles. |
| singleTile | {Boolean} Moves the layer into single-tile mode, meaning that one tile will be loaded. |
| 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. |
| buffer | {Integer} Used only when in gridded mode, this specifies the number of extra rows and colums of tiles on each side which will surround the minimum grid tiles to cover the map. |
| transitionEffect | {String} The transition effect to use when the map is zoomed. |
| numLoadingTiles | {Integer} How many tiles are still loading? |
| serverResolutions | {Array(Number}} This property is documented in subclasses as an API property. |
| loading | {Boolean} Indicates if tiles are being loaded. |
| backBuffer | {DOMElement} The back buffer. |
| gridResolution | {Number} The resolution of the current grid. |
| backBufferResolution | {Number} The resolution of the current back buffer. |
| backBufferLonLat | {Object} The top-left corner of the current back buffer. |
| backBufferTimerId | {Number} The id of the back buffer timer. |
| removeBackBufferDelay | {Number} Delay for removing the backbuffer when all tiles have finished loading. |
| className | {String} Name of the class added to the layer div. |
| gridLayout | {Object} Object containing properties tilelon, tilelat, startcol, startrow |
| rowSign | {Number} 1 for grids starting at the top, -1 for grids starting at the bottom. |
| transitionendEvents | {Array} Event names for transitionend |
| Constructor | |
| OpenLayers. | Create a new grid layer |
| Functions | |
| initProperties | Set any properties that depend on the value of singleTile. |
| setMap | |
| removeMap | Called when the layer is removed from the map. |
| destroy | Deconstruct the layer and clear the grid. |
| mergeNewParams | Refetches tiles with new params merged, keeping a backbuffer. |
| clearGrid | Go through and remove all tiles from the grid, calling destroy() on each of them to kill circular references |
| addOptions | |
| clone | Create a clone of this layer |
| moveTo | This function is called whenever the map is moved. |
| getTileData | Given a map location, retrieve a tile and the pixel offset within that tile corresponding to the location. |
| destroyTile | |
| getServerResolution | Return the closest server-supported resolution. |
| getServerZoom | Return the zoom value corresponding to the best matching server resolution, taking into account serverResolutions and <zoomOffset>. |
| applyBackBuffer | Create, insert, scale and position a back buffer for the layer. |
| createBackBuffer | Create a back buffer. |
| removeBackBuffer | Remove back buffer from DOM. |
| moveByPx | Move the layer based on pixel vector. |
| 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). |
| getTilesBounds | Return the bounds of the tile grid. |
| initSingleTile | |
| calculateGridLayout | Generate parameters for the grid layout. |
| getTileOrigin | Determine the origin for aligning the grid of tiles. |
| getTileBoundsForGridIndex | |
| initGriddedTiles | |
| getMaxExtent | Get this layer’s maximum extent. |
| addTile | Create a tile, initialize it, and add it to the layer div. |
| addTileMonitoringHooks | This function takes a tile as input and adds the appropriate hooks to the tile so that the layer can keep track of the loading tiles. |
| removeTileMonitoringHooks | This function takes a tile as input and removes the tile hooks that were added in addTileMonitoringHooks() |
| moveGriddedTiles | |
| shiftRow | Shifty grid work |
| shiftColumn | Shift grid work in the other dimension |
| removeExcessTiles | When the size of the map or the buffer changes, we may need to remove some excess rows and columns. |
| onMapResize | For singleTile layers, this will set a new tile size according to the dimensions of the map pane. |
| getTileBounds | Returns The tile bounds for a layer given a pixel location. |
{String} If the tileOrigin property is not provided, the tile origin will be derived from the layer’s maxExtent. The corner of the maxExtent used is determined by this property. Acceptable values are “tl” (top left), “tr” (top right), “bl” (bottom left), and “br” (bottom right). Default is “bl”.
{OpenLayers.LonLat} Optional origin for aligning the grid of tiles. If provided, requests for tiles at all resolutions will be aligned with this location (no tiles shall overlap this location). If not provided, the grid of tiles will be aligned with the layer’s maxExtent. Default is ``null``.
{Object} optional configuration options for OpenLayers.Tile instances created by this Layer, if supported by the tile class.
{OpenLayers.Tile} The tile class to use for this layer. Defaults is OpenLayers.Tile.Image.
{Array(Array(OpenLayers.Tile))} This is an array of rows, each row is an array of tiles.
{Integer} Used only when in gridded mode, this specifies the number of extra rows and colums of tiles on each side which will surround the minimum grid tiles to cover the map. For very slow loading layers, a larger value may increase performance somewhat when dragging, but will increase bandwidth use significantly.
{String} The transition effect to use when the map is zoomed. Two posible values:
| ”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 on top of the resized tiles (this is the default setting). |
| ”map-resize” | Existing tiles are resized on zoom and placed below the base layer. New tiles for the base layer will cover existing tiles. This setting is recommended when having an overlay duplicated during the transition is undesirable (e.g. street labels or big transparent fills). |
| null | No transition effect. |
Using “resize” on non-opaque layers can cause undesired visual effects. Set transitionEffect to null in this case.
{Number} Delay for removing the backbuffer when all tiles have finished loading. Can be set to 0 when no css opacity transitions for the olTileImage class are used. Default is 0 for singleTile layers, 2500 for tiled layers. See className for more information on tile animation.
{String} Name of the class added to the layer div. If not set in the options passed to the constructor then className defaults to “olLayerGridSingleTile” for single tile layers (see singleTile), and “olLayerGrid” for non single tile layers.
The displaying of tiles is not animated by default for single tile layers - OpenLayers’ default theme (style.css) includes this:
.olLayerGrid .olTileImage {
-webkit-transition: opacity 0.2s linear;
-moz-transition: opacity 0.2s linear;
-o-transition: opacity 0.2s linear;
transition: opacity 0.2s linear;
}To animate tile displaying for any grid layer the following CSS rule can be used:
.olTileImage {
-webkit-transition: opacity 0.2s linear;
-moz-transition: opacity 0.2s linear;
-o-transition: opacity 0.2s linear;
transition: opacity 0.2s linear;
}In that case, to avoid flash effects, removeBackBufferDelay should not be zero.
removeMap: function( map )
Called when the layer is removed from the map.
| map | {OpenLayers.Map} The map. |
Refetches tiles with new params merged, keeping a backbuffer. Each loading new tile will have a css class of ‘.olTileReplacing’. If a stylesheet applies a ‘display: none’ style to that class, any fade-in transition will not apply, and backbuffers for each tile will be removed as soon as the tile is loaded.
| newParams | {Object} |
redrawn: {Boolean} whether the layer was actually redrawn.
addOptions: function ( newOptions, reinitialize )
| newOptions | {Object} |
| reinitialize | {Boolean} If set to true, and if resolution options of the current baseLayer were changed, the map will be recentered to make sure that it is displayed with a valid resolution, and a changebaselayer event will be triggered. |
clone: function ( obj )
Create a clone of this layer
| obj | {Object} Is this ever used? |
{OpenLayers.Layer.Grid} An exact clone of this OpenLayers.Layer.Grid
moveTo:function( bounds, zoomChanged, dragging )
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 a bounds and make sure the data that that bounds requires is pre-loaded.
| bounds | {OpenLayers.Bounds} |
| zoomChanged | {Boolean} |
| dragging | {Boolean} |
getTileData: function( loc )
Given a map location, retrieve a tile and the pixel offset within that tile corresponding to the location. If there is not an existing tile in the grid that covers the given location, null will be returned.
| loc | {OpenLayers.LonLat} map location |
{Object} Object with the following properties: tile ({OpenLayers.Tile}), i ({Number} x-pixel offset from top left), and j ({Integer} y-pixel offset from top left).
getServerZoom: function()
Return the zoom value corresponding to the best matching server resolution, taking into account serverResolutions and <zoomOffset>.
{Number} The closest server supported zoom. This is not the map zoom level, but an index of the server’s resolutions array.
setTileSize: function( size )
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).
| size | {OpenLayers.Size} |
getTilesBounds: function()
Return the bounds of the tile grid.
{OpenLayers.Bounds} A Bounds object representing the bounds of all the currently loaded tiles (including those partially or not at all seen onscreen).
calculateGridLayout: function( bounds, origin, resolution )
Generate parameters for the grid layout.
| bounds | {<OpenLayers.Bound>|Object} OpenLayers.Bounds or an object with a ‘left’ and ‘top’ properties. |
| origin | {<OpenLayers.LonLat>|Object} OpenLayers.LonLat or an object with a ‘lon’ and ‘lat’ properties. |
| resolution | {Number} |
{Object} Object containing properties tilelon, tilelat, startcol, startrow
getTileOrigin: function()
Determine the origin for aligning the grid of tiles. If a tileOrigin property is supplied, that will be returned. Otherwise, the origin will be derived from the layer’s maxExtent property. In this case, the tile origin will be the corner of the maxExtent given by the tileOriginCorner property.
{OpenLayers.LonLat} The tile origin.
getTileBoundsForGridIndex: function( row, col )
| row | {Number} The row of the grid |
| col | {Number} The column of the grid |
{OpenLayers.Bounds} The bounds for the tile at (row, col)
addTile: function( bounds, position )
Create a tile, initialize it, and add it to the layer div.
Parameters bounds - {OpenLayers.Bounds} position - {OpenLayers.Pixel}
{OpenLayers.Tile} The added OpenLayers.Tile
addTileMonitoringHooks: function( tile )
This function takes a tile as input and adds the appropriate hooks to the tile so that the layer can keep track of the loading tiles.
| tile | {OpenLayers.Tile} |
removeTileMonitoringHooks: function( tile )
This function takes a tile as input and removes the tile hooks that were added in addTileMonitoringHooks()
| tile | {OpenLayers.Tile} |
getTileBounds: function( viewPortPx )
Returns The tile bounds for a layer given a pixel location.
| viewPortPx | {OpenLayers.Pixel} The location in the viewport. |
{OpenLayers.Bounds} Bounds of the tile at the given pixel location.
Set any properties that depend on the value of singleTile.
initProperties: function()
setMap: function( map )
Called when the layer is removed from the map.
removeMap: function( map )
Deconstruct the layer and clear the grid.
destroy: function()
Go through and remove all tiles from the grid, calling destroy() on each of them to kill circular references
clearGrid:function()
addOptions: function ( newOptions, reinitialize )
Create a clone of this layer
clone: function ( obj )
This function is called whenever the map is moved.
moveTo:function( bounds, zoomChanged, dragging )
Given a map location, retrieve a tile and the pixel offset within that tile corresponding to the location.
getTileData: function( loc )
destroyTile: function( tile )
Return the closest server-supported resolution.
getServerResolution: function( resolution )
Return the zoom value corresponding to the best matching server resolution, taking into account serverResolutions and zoomOffset.
getServerZoom: function()
Create, insert, scale and position a back buffer for the layer.
applyBackBuffer: function( resolution )
Create a back buffer.
createBackBuffer: function()
Remove back buffer from DOM.
removeBackBuffer: function()
Move the layer based on pixel vector.
moveByPx: function( dx, dy )
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).
setTileSize: function( size )
Return the bounds of the tile grid.
getTilesBounds: function()
initSingleTile: function( bounds )
Generate parameters for the grid layout.
calculateGridLayout: function( bounds, origin, resolution )
Determine the origin for aligning the grid of tiles.
getTileOrigin: function()
getTileBoundsForGridIndex: function( row, col )
initGriddedTiles:function( bounds )
Get this layer’s maximum extent.
getMaxExtent: function()
Create a tile, initialize it, and add it to the layer div.
addTile: function( bounds, position )
This function takes a tile as input and adds the appropriate hooks to the tile so that the layer can keep track of the loading tiles.
addTileMonitoringHooks: function( tile )
This function takes a tile as input and removes the tile hooks that were added in addTileMonitoringHooks()
removeTileMonitoringHooks: function( tile )
moveGriddedTiles: function()
Shifty grid work
shiftRow: function( prepend, tileSize )
Shift grid work in the other dimension
shiftColumn: function( prepend, tileSize )
When the size of the map or the buffer changes, we may need to remove some excess rows and columns.
removeExcessTiles: function( rows, columns )
For singleTile layers, this will set a new tile size according to the dimensions of the map pane.
onMapResize: function()
Returns The tile bounds for a layer given a pixel location.
getTileBounds: function( viewPortPx )