Constructor: OpenLayers.Layer.Grid Create a new grid layer
Parameters: name - {String} url - {String} params - {Object} options - {Object} Hashtable of extra options to tag onto the layer
The properties that are used for calculating resolutions information.
The layer's images have an alpha channel. Default is false.
If a layer's display should not be scale-based, this should be set to true. This will cause the layer, as an overlay, to always be 'active', by always returning true from the calculateInRange() function.
If not explicitly specified for a layer, its value will be determined on startup in initResolutions() based on whether or not any scale-specific properties have been set as options on the layer. If no scale-specific options have been set on the layer, we assume that it should always be in range.
Attribution string, displayed when an
Property: backBuffer {DOMElement} The back buffer.
Property: backBufferLonLat {Object} The top-left corner of the current back buffer. Includes lon and lat properties. This object is updated each time a back buffer is created.
Property: backBufferResolution {Number} The resolution of the current back buffer. This property is updated each time a back buffer is created.
Property: backBufferTimerId {Number} The id of the back buffer timer. This timer is used to delay the removal of the back buffer, thereby preventing flash effects caused by tile animation.
APIProperty: buffer {Integer} Used only when in gridded mode, this specifies the number of extra rows and columns 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.
APIProperty: className
{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
Note:
The displaying of tiles is not animated by default for single tile
layers - OpenLayers' default theme (style.css) includes this:
(code)
.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;
}
(end)
To animate tile displaying for any grid layer the following
CSS rule can be used:
(code)
.olTileImage {
-webkit-transition: opacity 0.2s linear;
-moz-transition: opacity 0.2s linear;
-o-transition: opacity 0.2s linear;
transition: opacity 0.2s linear;
}
(end)
In that case, to avoid flash effects,
Display the layer's name in the layer switcher. Default is true
Request map tiles that are completely outside of the max extent for this layer. Defaults to false.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
APIProperty: events
{
Register a listener for a particular event with the following syntax: (code) layer.events.register(type, obj, listener); (end)
Listeners will be called with a reference to an event object. The properties of this event depends on exactly what happened.
All event objects have at least the following properties: object - {Object} A reference to layer.events.object. element - {DOMElement} A reference to layer.events.element.
Supported map event types:
loadstart - Triggered when layer loading starts. When using a Vector
layer with a Fixed or BBOX strategy, the event object includes
a filter property holding the OpenLayers.Filter used when
calling read on the protocol.
loadend - Triggered when layer loading ends. When using a Vector layer
with a Fixed or BBOX strategy, the event object includes a
response property holding an OpenLayers.Protocol.Response object.
visibilitychanged - Triggered when the layer's visibility property is
changed, e.g. by turning the layer on or off in the layer switcher.
Note that the actual visibility of the layer can also change if it
gets out of range (see
Property: grid
{Array(Array(
Property: gridLayout {Object} Object containing properties tilelon, tilelat, startcol, startrow
Property: gridResolution {Number} The resolution of the current grid. Used for backbuffer and client zoom. This property is updated every time the grid is initialized.
Determines the width (in pixels) of the gutter around image tiles to ignore. By setting this property to a non-zero value, images will be requested that are wider and taller than the tile size by a value of 2 x gutter. This allows artifacts of rendering at tile edges to be ignored. Set a gutter value that is equal to half the size of the widest symbol that needs to be displayed. Defaults to zero. Non-tiled layers always have zero gutter.
For layers with a gutter, the image is larger than the tile by twice the gutter in each dimension.
The current map resolution is within the layer's min/max
range. This is set in
Whether or not the layer is a base layer. This should be set individually by all subclasses. Default is false
Property: loading {Boolean} Indicates if tiles are being loaded.
This variable is set when the layer is added to the map, via the accessor function setMap()
The maximum extent for the layer. Defaults to null.
Default max is 360 deg / 256 px, which corresponds to
zoom level 0 on gmaps. Specify a different value in the layer
options if you are not using the default
This object can be used to store additional information on a layer object.
The minimum extent for the layer. Defaults to null.
APIProperty: numLoadingTiles {Integer} How many tiles are still loading?
The layer's opacity. Float number between 0.0 and 1.0.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
Property: params {Object} Hashtable of key/value parameters
Specifies the projection of the layer. Can be set in the layer options. If not specified in the layer options, it is set to the default projection specified in the map, when the layer is added to the map. Projection along with default maxExtent and resolutions are set automatically with commercial baselayers in EPSG:3857, such as Google, Bing and OpenStreetMap, and do not need to be specified. Otherwise, if specifying projection, also set maxExtent, maxResolution or resolutions as appropriate. When using vector layers with strategies, layer projection should be set to the projection of the source data if that is different from the map default.
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. Default value is 1.5.
APIProperty: removeBackBufferDelay
{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
APIProperty: reproject Deprecated. See http://docs.openlayers.org/library/spherical_mercator.html for information on the replacement for this functionality. {Boolean} Whether layer should reproject itself based on base layer locations. This allows reprojection onto commercial layers. Default is false: Most layers can't reproject, but layers which can create non-square geographic pixels can, like WMS.
A list of map resolutions (map units per pixel) in descending order. If this is not set in the layer constructor, it will be set based on other resolution related properties (maxExtent, maxResolution, maxScale, etc.).
Property: rowSign {Number} 1 for grids starting at the top, -1 for grids starting at the bottom. This is used for several grid index and offset calculations.
An array of map scales in descending order. The values in the
array correspond to the map scale denominator. Note that these
values only make sense if the display (monitor) resolution of the
client is correctly guessed by whomever is configuring the
application. In addition, the units property must also be set.
Use
Property: serverResolutions {Array(Number}} This property is documented in subclasses as an API property.
APIProperty: singleTile {Boolean} Moves the layer into single-tile mode, meaning that one tile will be loaded. The tile's size will be determined by the 'ratio' property. When the tile is dragged such that it does not cover the entire viewport, it is reloaded.
APIProperty: tileClass
{
APIProperty: tileOptions
{Object} optional configuration options for
APIProperty: tileOrigin
{
null
.
Property: tileOriginCorner
{String} If the
APIProperty: tileSize
{
APIProperty: transitionEffect {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.
Property: transitionendEvents {Array} Event names for transitionend
The layer map units. Defaults to null. Possible values are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. Normally taken from the projection. Only required if both map and layers do not define a projection, or if they define a projection which does not define units.
Property: url {Array(String) or String} This is either an array of url strings or a single url string.
The layer should be displayed in the map. Default is true.
Wraps the world at the international dateline, so the map can be panned infinitely in longitudinal direction. Only use this on the base layer, and only if the layer's maxExtent equals the world bounds.
APIMethod: addOptions
Parameters: 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.
APIMethod: addTile Create a tile, initialize it, and add it to the layer div.
Parameters
bounds - {
Returns:
{
Method: 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.
Parameters:
tile - {
Method: adjustBounds This function will take a bounds, and if wrapDateLine option is set on the layer, it will return a bounds which is wrapped around the world. We do not wrap for bounds which cross the maxExtent.left/right, only bounds which are entirely to the left or entirely to the right.
Parameters:
bounds - {
Method: applyBackBuffer Create, insert, scale and position a back buffer for the layer.
Parameters: resolution - {Number} The resolution to transition to.
Method: calculateGridLayout Generate parameters for the grid layout.
Parameters:
bounds - {
Returns: {Object} Object containing properties tilelon, tilelat, startcol, startrow
{ tilelon: number; tilelat: number; startcol: number; startrow: number; }
APIMethod: calculateInRange
Returns: {Boolean} The layer is displayable at the current map's current resolution. Note that if 'alwaysInRange' is true for the layer, this function will always return true.
boolean
Method: calculateResolutions Calculate resolutions based on the provided properties.
Parameters: props - {Object} Properties
Returns: {Array({Number})} Array of resolutions.
Array<number>
Method: clearGrid Go through and remove all tiles from the grid, calling destroy() on each of them to kill circular references
APIMethod: clone Create a clone of this layer
Parameters: obj - {Object} Is this ever used?
Returns:
{
Method: createBackBuffer Create a back buffer.
Returns: {DOMElement} The DOM element for the back buffer, undefined if the grid isn't initialized yet.
HTMLElement
APIMethod: destroy Deconstruct the layer and clear the grid.
Method: destroyTile
Parameters:
tile - {
APIMethod: display Hide or show the Layer. This is designed to be used internally, and is not generally the way to enable or disable the layer. For that, use the setVisibility function instead..
Parameters: display - {Boolean}
APIMethod: getExtent
Returns:
{
Method: getFullRequestString Combine url with layer's params and these newParams.
does checking on the serverPath variable, allowing for cases when it is supplied with trailing ? or &, as well as cases where not.
return in formatted string like this: "server?key1=value1&key2=value2&key3=value3"
WARNING: The altUrl parameter is deprecated and will be removed in 3.0.
Parameters: newParams - {Object} altUrl - {String} Use this as the url instead of the layer's url
Returns: {String}
string
APIMethod: getLonLatFromViewPortPx
Parameters:
viewPortPx - {
Returns:
{
Method: getMaxExtent Get this layer's maximum extent. (Implemented as a getter for potential specific implementations in sub-classes.)
Returns:
{
APIMethod: getResolution
Returns: {Float} The currently selected resolution of the map, taken from the resolutions array, indexed by current zoom level.
number
APIMethod: getResolutionForZoom
Parameters: zoom - {Float}
Returns: {Float} A suitable resolution for the specified zoom.
number
Method: getServerResolution Return the closest server-supported resolution.
Parameters: resolution - {Number} The base resolution. If undefined the map resolution is used.
Returns: {Number} The closest server resolution value.
number
Method: getServerZoom
Return the zoom value corresponding to the best matching server
resolution, taking into account
Returns: {Number} The closest server supported zoom. This is not the map zoom level, but an index of the server's resolutions array.
number
APIMethod: getTileBounds Returns The tile bounds for a layer given a pixel location.
Parameters:
viewPortPx - {
Returns:
{
Method: getTileBoundsForGridIndex
Parameters: row - {Number} The row of the grid col - {Number} The column of the grid
Returns:
{
Method: getTileData 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.
Parameters:
loc - {
Returns:
{Object} Object with the following properties: tile ({
{ tile: OpenLayers.Tile; i: number; j: number; }
Method: getTileOrigin
Determine the origin for aligning the grid of tiles. If a
Returns:
{
APIMethod: getTilesBounds Return the bounds of the tile grid.
Returns:
{
APIMethod: getViewPortPxFromLonLat Returns a pixel location given a map location. This method will return fractional pixel values.
Parameters:
lonlat - {
Returns:
{
APIMethod: getVisibility
Returns: {Boolean} The layer should be displayed (if in range).
boolean
Method: getZIndex
Returns: {Integer} the z-index of this layer
number
APIMethod: getZoomForExtent
Parameters:
extent - {
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) for the passed-in extent. We do this by calculating the ideal resolution for the given extent (based on the map size) and then calling getZoomForResolution(), passing along the 'closest' parameter.
number
APIMethod: getZoomForResolution
Parameters: resolution - {Float} closest - {Boolean} Find the zoom level that corresponds to the absolute closest resolution, which may result in a zoom whose corresponding resolution is actually smaller than we would have desired (if this is being called from a getZoomForExtent() call, then this means that the returned zoom index might not actually contain the entire extent specified... but it'll be close). Default is false.
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) that corresponds to the best fit resolution given the passed in value and the 'closest' specification.
number
Method: initGriddedTiles
Parameters:
bounds - {
Method: initProperties Set any properties that depend on the value of singleTile. Currently sets removeBackBufferDelay and className
Method: initResolutions This method's responsibility is to set up the 'resolutions' array for the layer -- this array is what the layer will use to interface between the zoom levels of the map and the resolution display of the layer.
The user has several options that determine how the array is set up.
For a detailed explanation, see the following wiki from the openlayers.org homepage: http://trac.openlayers.org/wiki/SettingZoomLevels
Method: initSingleTile
Parameters:
bounds - {
any
APIMethod: mergeNewParams
Parameters: newParams - {Object}
Returns: redrawn: {Boolean} whether the layer was actually redrawn.
boolean
Method: moveByPx Move the layer based on pixel vector.
Parameters: dx - {Number} dy - {Number}
Method: moveGriddedTiles
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 a bounds and make sure the data that that bounds requires is pre-loaded.
Parameters:
bounds - {
Method: onMapResize For singleTile layers, this will set a new tile size according to the dimensions of the map pane.
APIMethod: redraw Redraws the layer. Returns true if the layer was redrawn, false if not.
Parameters: force - {Boolean} Force redraw by adding random parameter.
Returns: {Boolean} The layer was redrawn.
boolean
Method: removeBackBuffer Remove back buffer from DOM.
Method: removeExcessTiles When the size of the map or the buffer changes, we may need to remove some excess rows and columns.
Parameters: rows - {Integer} Maximum number of rows we want our grid to have. columns - {Integer} Maximum number of columns we want our grid to have.
Method: removeMap Called when the layer is removed from the map.
Parameters:
map - {
Method: removeTileMonitoringHooks This function takes a tile as input and removes the tile hooks that were added in addTileMonitoringHooks()
Parameters:
tile - {
APIMethod: setIsBaseLayer
Parameters: isBaseLayer - {Boolean}
Method: setMap
Parameters:
map - {
APIMethod: setName Sets the new layer name for this layer. Can trigger a changelayer event on the map.
Parameters: newName - {String} The new name.
APIMethod: setOpacity Sets the opacity for the entire layer (all images)
Parameters: opacity - {Float}
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 - {
APIMethod: setUrl
Parameters: newUrl - {String}
APIMethod: setVisibility Set the visibility flag for the layer and hide/show & redraw accordingly. Fire event unless otherwise specified
Note that visibility is no longer simply whether or not the layer's style.display is set to "block". Now we store a 'visibility' state property on the layer class, this allows us to remember whether or not we desire for a layer to be visible. In the case where the map's resolution is out of the layer's range, this desire may be subverted.
Parameters: visibility - {Boolean} Whether or not to display the layer (if in range)
Method: setZIndex
Parameters: zIndex - {Integer}
Method: shiftColumn Shift grid work in the other dimension
Parameters: prepend - {Boolean} if true, prepend to beginning. if false, then append to end tileSize - {Object} rendered tile size; object with w and h properties
Method: shiftRow Shifty grid work
Parameters: prepend - {Boolean} if true, prepend to beginning. if false, then append to end tileSize - {Object} rendered tile size; object with w and h properties
Constructor: OpenLayers.Layer.HTTPRequest
Parameters: name - {String} url - {Array(String) or String} params - {Object} options - {Object} Hashtable of extra options to tag onto the layer
The properties that are used for calculating resolutions information.
Constant: URL_HASH_FACTOR {Float} Used to hash URL param strings for multi-WMS server selection. Set to the Golden Ratio per Knuth's recommendation.
The layer's images have an alpha channel. Default is false.
If a layer's display should not be scale-based, this should be set to true. This will cause the layer, as an overlay, to always be 'active', by always returning true from the calculateInRange() function.
If not explicitly specified for a layer, its value will be determined on startup in initResolutions() based on whether or not any scale-specific properties have been set as options on the layer. If no scale-specific options have been set on the layer, we assume that it should always be in range.
Attribution string, displayed when an
Display the layer's name in the layer switcher. Default is true
Request map tiles that are completely outside of the max extent for this layer. Defaults to false.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
APIProperty: events
{
Register a listener for a particular event with the following syntax: (code) layer.events.register(type, obj, listener); (end)
Listeners will be called with a reference to an event object. The properties of this event depends on exactly what happened.
All event objects have at least the following properties: object - {Object} A reference to layer.events.object. element - {DOMElement} A reference to layer.events.element.
Supported map event types:
loadstart - Triggered when layer loading starts. When using a Vector
layer with a Fixed or BBOX strategy, the event object includes
a filter property holding the OpenLayers.Filter used when
calling read on the protocol.
loadend - Triggered when layer loading ends. When using a Vector layer
with a Fixed or BBOX strategy, the event object includes a
response property holding an OpenLayers.Protocol.Response object.
visibilitychanged - Triggered when the layer's visibility property is
changed, e.g. by turning the layer on or off in the layer switcher.
Note that the actual visibility of the layer can also change if it
gets out of range (see
Determines the width (in pixels) of the gutter around image tiles to ignore. By setting this property to a non-zero value, images will be requested that are wider and taller than the tile size by a value of 2 x gutter. This allows artifacts of rendering at tile edges to be ignored. Set a gutter value that is equal to half the size of the widest symbol that needs to be displayed. Defaults to zero. Non-tiled layers always have zero gutter.
For layers with a gutter, the image is larger than the tile by twice the gutter in each dimension.
The current map resolution is within the layer's min/max
range. This is set in
Whether or not the layer is a base layer. This should be set individually by all subclasses. Default is false
This variable is set when the layer is added to the map, via the accessor function setMap()
The maximum extent for the layer. Defaults to null.
Default max is 360 deg / 256 px, which corresponds to
zoom level 0 on gmaps. Specify a different value in the layer
options if you are not using the default
This object can be used to store additional information on a layer object.
The minimum extent for the layer. Defaults to null.
The layer's opacity. Float number between 0.0 and 1.0.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
Property: params {Object} Hashtable of key/value parameters
Specifies the projection of the layer. Can be set in the layer options. If not specified in the layer options, it is set to the default projection specified in the map, when the layer is added to the map. Projection along with default maxExtent and resolutions are set automatically with commercial baselayers in EPSG:3857, such as Google, Bing and OpenStreetMap, and do not need to be specified. Otherwise, if specifying projection, also set maxExtent, maxResolution or resolutions as appropriate. When using vector layers with strategies, layer projection should be set to the projection of the source data if that is different from the map default.
APIProperty: reproject Deprecated. See http://docs.openlayers.org/library/spherical_mercator.html for information on the replacement for this functionality. {Boolean} Whether layer should reproject itself based on base layer locations. This allows reprojection onto commercial layers. Default is false: Most layers can't reproject, but layers which can create non-square geographic pixels can, like WMS.
A list of map resolutions (map units per pixel) in descending order. If this is not set in the layer constructor, it will be set based on other resolution related properties (maxExtent, maxResolution, maxScale, etc.).
An array of map scales in descending order. The values in the
array correspond to the map scale denominator. Note that these
values only make sense if the display (monitor) resolution of the
client is correctly guessed by whomever is configuring the
application. In addition, the units property must also be set.
Use
The layer map units. Defaults to null. Possible values are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. Normally taken from the projection. Only required if both map and layers do not define a projection, or if they define a projection which does not define units.
Property: url {Array(String) or String} This is either an array of url strings or a single url string.
The layer should be displayed in the map. Default is true.
Wraps the world at the international dateline, so the map can be panned infinitely in longitudinal direction. Only use this on the base layer, and only if the layer's maxExtent equals the world bounds.
APIMethod: addOptions
Parameters: 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.
Method: adjustBounds This function will take a bounds, and if wrapDateLine option is set on the layer, it will return a bounds which is wrapped around the world. We do not wrap for bounds which cross the maxExtent.left/right, only bounds which are entirely to the left or entirely to the right.
Parameters:
bounds - {
APIMethod: calculateInRange
Returns: {Boolean} The layer is displayable at the current map's current resolution. Note that if 'alwaysInRange' is true for the layer, this function will always return true.
boolean
Method: calculateResolutions Calculate resolutions based on the provided properties.
Parameters: props - {Object} Properties
Returns: {Array({Number})} Array of resolutions.
Array<number>
APIMethod: clone
Parameters: obj - {Object}
Returns:
{
APIMethod: destroy
APIMethod: display Hide or show the Layer. This is designed to be used internally, and is not generally the way to enable or disable the layer. For that, use the setVisibility function instead..
Parameters: display - {Boolean}
APIMethod: getExtent
Returns:
{
Method: getFullRequestString Combine url with layer's params and these newParams.
does checking on the serverPath variable, allowing for cases when it is supplied with trailing ? or &, as well as cases where not.
return in formatted string like this: "server?key1=value1&key2=value2&key3=value3"
WARNING: The altUrl parameter is deprecated and will be removed in 3.0.
Parameters: newParams - {Object} altUrl - {String} Use this as the url instead of the layer's url
Returns: {String}
string
APIMethod: getImageSize
Parameters:
bounds - {
Returns:
{
APIMethod: getLonLatFromViewPortPx
Parameters:
viewPortPx - {
Returns:
{
APIMethod: getResolution
Returns: {Float} The currently selected resolution of the map, taken from the resolutions array, indexed by current zoom level.
number
APIMethod: getResolutionForZoom
Parameters: zoom - {Float}
Returns: {Float} A suitable resolution for the specified zoom.
number
APIMethod: getViewPortPxFromLonLat Returns a pixel location given a map location. This method will return fractional pixel values.
Parameters:
lonlat - {
Returns:
{
APIMethod: getVisibility
Returns: {Boolean} The layer should be displayed (if in range).
boolean
Method: getZIndex
Returns: {Integer} the z-index of this layer
number
APIMethod: getZoomForExtent
Parameters:
extent - {
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) for the passed-in extent. We do this by calculating the ideal resolution for the given extent (based on the map size) and then calling getZoomForResolution(), passing along the 'closest' parameter.
number
APIMethod: getZoomForResolution
Parameters: resolution - {Float} closest - {Boolean} Find the zoom level that corresponds to the absolute closest resolution, which may result in a zoom whose corresponding resolution is actually smaller than we would have desired (if this is being called from a getZoomForExtent() call, then this means that the returned zoom index might not actually contain the entire extent specified... but it'll be close). Default is false.
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) that corresponds to the best fit resolution given the passed in value and the 'closest' specification.
number
Method: initResolutions This method's responsibility is to set up the 'resolutions' array for the layer -- this array is what the layer will use to interface between the zoom levels of the map and the resolution display of the layer.
The user has several options that determine how the array is set up.
For a detailed explanation, see the following wiki from the openlayers.org homepage: http://trac.openlayers.org/wiki/SettingZoomLevels
APIMethod: mergeNewParams
Parameters: newParams - {Object}
Returns: redrawn: {Boolean} whether the layer was actually redrawn.
boolean
Method: moveByPx Move the layer based on pixel vector. To be implemented by subclasses.
Parameters: dx - {Number} The x coord of the displacement vector. dy - {Number} The y coord of the displacement vector.
Method: moveTo
Parameters:
bounds - {
This function can be implemented by subclasses
APIMethod: redraw Redraws the layer. Returns true if the layer was redrawn, false if not.
Parameters: force - {Boolean} Force redraw by adding random parameter.
Returns: {Boolean} The layer was redrawn.
boolean
APIMethod: removeMap Just as setMap() allows each layer the possibility to take a personalized action on being added to the map, removeMap() allows each layer to take a personalized action on being removed from it. For now, this will be mostly unused, except for the EventPane layer, which needs this hook so that it can remove the special invisible pane.
Parameters:
map - {
Method: selectUrl selectUrl() implements the standard floating-point multiplicative hash function described by Knuth, and hashes the contents of the given param string into a float between 0 and 1. This float is then scaled to the size of the provided urls array, and used to select a URL.
Parameters: paramString - {String} urls - {Array(String)}
Returns: {String} An entry from the urls array, deterministically selected based on the paramString.
string
APIMethod: setIsBaseLayer
Parameters: isBaseLayer - {Boolean}
Method: setMap Set the map property for the layer. This is done through an accessor so that subclasses can override this and take special action once they have their map variable set.
Here we take care to bring over any of the necessary default properties from the map.
Parameters:
map - {
APIMethod: setName Sets the new layer name for this layer. Can trigger a changelayer event on the map.
Parameters: newName - {String} The new name.
APIMethod: setOpacity Sets the opacity for the entire layer (all images)
Parameters: opacity - {Float}
APIMethod: setTileSize Set the tile size based on the map size. This also sets layer.imageSize or use by Tile.Image.
Parameters:
size - {
APIMethod: setUrl
Parameters: newUrl - {String}
APIMethod: setVisibility Set the visibility flag for the layer and hide/show & redraw accordingly. Fire event unless otherwise specified
Note that visibility is no longer simply whether or not the layer's style.display is set to "block". Now we store a 'visibility' state property on the layer class, this allows us to remember whether or not we desire for a layer to be visible. In the case where the map's resolution is out of the layer's range, this desire may be subverted.
Parameters: visibility - {Boolean} Whether or not to display the layer (if in range)
Method: setZIndex
Parameters: zIndex - {Integer}
The properties that are used for calculating resolutions information.
The layer's images have an alpha channel. Default is false.
If a layer's display should not be scale-based, this should be set to true. This will cause the layer, as an overlay, to always be 'active', by always returning true from the calculateInRange() function.
If not explicitly specified for a layer, its value will be determined on startup in initResolutions() based on whether or not any scale-specific properties have been set as options on the layer. If no scale-specific options have been set on the layer, we assume that it should always be in range.
The layer attribution.
Property: backBuffer {DOMElement} The back buffer.
Property: backBufferLonLat {Object} The top-left corner of the current back buffer. Includes lon and lat properties. This object is updated each time a back buffer is created.
Property: backBufferResolution {Number} The resolution of the current back buffer. This property is updated each time a back buffer is created.
Property: backBufferTimerId {Number} The id of the back buffer timer. This timer is used to delay the removal of the back buffer, thereby preventing flash effects caused by tile animation.
APIProperty: buffer {Integer} Used only when in gridded mode, this specifies the number of extra rows and columns 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.
APIProperty: className
{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
Note:
The displaying of tiles is not animated by default for single tile
layers - OpenLayers' default theme (style.css) includes this:
(code)
.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;
}
(end)
To animate tile displaying for any grid layer the following
CSS rule can be used:
(code)
.olTileImage {
-webkit-transition: opacity 0.2s linear;
-moz-transition: opacity 0.2s linear;
-o-transition: opacity 0.2s linear;
transition: opacity 0.2s linear;
}
(end)
In that case, to avoid flash effects,
Display the layer's name in the layer switcher. Default is true
Request map tiles that are completely outside of the max extent for this layer. Defaults to false.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
APIProperty: events
{
Register a listener for a particular event with the following syntax: (code) layer.events.register(type, obj, listener); (end)
Listeners will be called with a reference to an event object. The properties of this event depends on exactly what happened.
All event objects have at least the following properties: object - {Object} A reference to layer.events.object. element - {DOMElement} A reference to layer.events.element.
Supported map event types:
loadstart - Triggered when layer loading starts. When using a Vector
layer with a Fixed or BBOX strategy, the event object includes
a filter property holding the OpenLayers.Filter used when
calling read on the protocol.
loadend - Triggered when layer loading ends. When using a Vector layer
with a Fixed or BBOX strategy, the event object includes a
response property holding an OpenLayers.Protocol.Response object.
visibilitychanged - Triggered when the layer's visibility property is
changed, e.g. by turning the layer on or off in the layer switcher.
Note that the actual visibility of the layer can also change if it
gets out of range (see
Property: grid
{Array(Array(
Property: gridLayout {Object} Object containing properties tilelon, tilelat, startcol, startrow
Property: gridResolution {Number} The resolution of the current grid. Used for backbuffer and client zoom. This property is updated every time the grid is initialized.
Determines the width (in pixels) of the gutter around image tiles to ignore. By setting this property to a non-zero value, images will be requested that are wider and taller than the tile size by a value of 2 x gutter. This allows artifacts of rendering at tile edges to be ignored. Set a gutter value that is equal to half the size of the widest symbol that needs to be displayed. Defaults to zero. Non-tiled layers always have zero gutter.
For layers with a gutter, the image is larger than the tile by twice the gutter in each dimension.
The current map resolution is within the layer's min/max
range. This is set in
APIProperty: isBaseLayer Default is true, as this is designed to be a base tile source.
Property: loading {Boolean} Indicates if tiles are being loaded.
This variable is set when the layer is added to the map, via the accessor function setMap()
The maximum extent for the layer. Defaults to null.
Default max is 360 deg / 256 px, which corresponds to
zoom level 0 on gmaps. Specify a different value in the layer
options if you are not using the default
This object can be used to store additional information on a layer object.
The minimum extent for the layer. Defaults to null.
The layer name. Defaults to "OpenStreetMap" if the first argument to the constructor is null or undefined.
APIProperty: numLoadingTiles {Integer} How many tiles are still loading?
The layer's opacity. Float number between 0.0 and 1.0.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
Property: params {Object} Hashtable of key/value parameters
Specifies the projection of the layer. Can be set in the layer options. If not specified in the layer options, it is set to the default projection specified in the map, when the layer is added to the map. Projection along with default maxExtent and resolutions are set automatically with commercial baselayers in EPSG:3857, such as Google, Bing and OpenStreetMap, and do not need to be specified. Otherwise, if specifying projection, also set maxExtent, maxResolution or resolutions as appropriate. When using vector layers with strategies, layer projection should be set to the projection of the source data if that is different from the map default.
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. Default value is 1.5.
APIProperty: removeBackBufferDelay
{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
APIProperty: reproject Deprecated. See http://docs.openlayers.org/library/spherical_mercator.html for information on the replacement for this functionality. {Boolean} Whether layer should reproject itself based on base layer locations. This allows reprojection onto commercial layers. Default is false: Most layers can't reproject, but layers which can create non-square geographic pixels can, like WMS.
A list of map resolutions (map units per pixel) in descending order. If this is not set in the layer constructor, it will be set based on other resolution related properties (maxExtent, maxResolution, maxScale, etc.).
Property: rowSign {Number} 1 for grids starting at the top, -1 for grids starting at the bottom. This is used for several grid index and offset calculations.
An array of map scales in descending order. The values in the
array correspond to the map scale denominator. Note that these
values only make sense if the display (monitor) resolution of the
client is correctly guessed by whomever is configuring the
application. In addition, the units property must also be set.
Use
APIProperty: serverResolutions
{Array} A list of all resolutions available on the server. Only set this
property if the map resolutions differ from the server. This
property serves two purposes. (a)
APIProperty: singleTile {Boolean} Moves the layer into single-tile mode, meaning that one tile will be loaded. The tile's size will be determined by the 'ratio' property. When the tile is dragged such that it does not cover the entire viewport, it is reloaded.
APIProperty: sphericalMercator Whether the tile extents should be set to the defaults for spherical mercator. Useful for things like OpenStreetMap. Default is false, except for the OSM subclass.
APIProperty: tileClass
{
optional configuration options for
APIProperty: tileOrigin
{
null
.
Property: tileOriginCorner
{String} If the
APIProperty: tileSize
{
APIProperty: transitionEffect {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.
Property: transitionendEvents {Array} Event names for transitionend
The layer map units. Defaults to null. Possible values are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. Normally taken from the projection. Only required if both map and layers do not define a projection, or if they define a projection which does not define units.
The tileset URL scheme. Defaults to : http://[a|b|c].tile.openstreetmap.org/${z}/${x}/${y}.png (the official OSM tileset) if the second argument to the constructor is null or undefined. To use another tileset you can have something like this: new OpenLayers.Layer.OSM("OpenCycleMap", ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]);
The layer should be displayed in the map. Default is true.
Wraps the world at the international dateline, so the map can be panned infinitely in longitudinal direction. Only use this on the base layer, and only if the layer's maxExtent equals the world bounds.
APIProperty: zoomOffset
{Number} If your cache has more zoom levels than you want to provide
access to with this layer, supply a zoomOffset. This zoom offset
is added to the current map zoom level to determine the level
for a requested tile. For example, if you supply a zoomOffset
of 3, when the map is at the zoom 0, tiles will be requested from
level 3 of your cache. Default is 0 (assumes cache level and map
zoom are equivalent). Using
APIMethod: addOptions
Parameters: 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.
APIMethod: addTile Create a tile, initialize it, and add it to the layer div.
Parameters
bounds - {
Returns:
{
Method: adjustBounds This function will take a bounds, and if wrapDateLine option is set on the layer, it will return a bounds which is wrapped around the world. We do not wrap for bounds which cross the maxExtent.left/right, only bounds which are entirely to the left or entirely to the right.
Parameters:
bounds - {
APIMethod: calculateInRange
Returns: {Boolean} The layer is displayable at the current map's current resolution. Note that if 'alwaysInRange' is true for the layer, this function will always return true.
boolean
Method: calculateResolutions Calculate resolutions based on the provided properties.
Parameters: props - {Object} Properties
Returns: {Array({Number})} Array of resolutions.
Array<number>
Create a clone of this layer
APIMethod: destroy Deconstruct the layer and clear the grid.
APIMethod: display Hide or show the Layer. This is designed to be used internally, and is not generally the way to enable or disable the layer. For that, use the setVisibility function instead..
Parameters: display - {Boolean}
APIMethod: getExtent
Returns:
{
Method: getFullRequestString Combine url with layer's params and these newParams.
does checking on the serverPath variable, allowing for cases when it is supplied with trailing ? or &, as well as cases where not.
return in formatted string like this: "server?key1=value1&key2=value2&key3=value3"
WARNING: The altUrl parameter is deprecated and will be removed in 3.0.
Parameters: newParams - {Object} altUrl - {String} Use this as the url instead of the layer's url
Returns: {String}
string
APIMethod: getLonLatFromViewPortPx
Parameters:
viewPortPx - {
Returns:
{
APIMethod: getResolution
Returns: {Float} The currently selected resolution of the map, taken from the resolutions array, indexed by current zoom level.
number
APIMethod: getResolutionForZoom
Parameters: zoom - {Float}
Returns: {Float} A suitable resolution for the specified zoom.
number
APIMethod: getTileBounds Returns The tile bounds for a layer given a pixel location.
Parameters:
viewPortPx - {
Returns:
{
APIMethod: getTilesBounds Return the bounds of the tile grid.
Returns:
{
APIMethod: getViewPortPxFromLonLat Returns a pixel location given a map location. This method will return fractional pixel values.
Parameters:
lonlat - {
Returns:
{
APIMethod: getVisibility
Returns: {Boolean} The layer should be displayed (if in range).
boolean
Method: getZIndex
Returns: {Integer} the z-index of this layer
number
APIMethod: getZoomForExtent
Parameters:
extent - {
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) for the passed-in extent. We do this by calculating the ideal resolution for the given extent (based on the map size) and then calling getZoomForResolution(), passing along the 'closest' parameter.
number
APIMethod: getZoomForResolution
Parameters: resolution - {Float} closest - {Boolean} Find the zoom level that corresponds to the absolute closest resolution, which may result in a zoom whose corresponding resolution is actually smaller than we would have desired (if this is being called from a getZoomForExtent() call, then this means that the returned zoom index might not actually contain the entire extent specified... but it'll be close). Default is false.
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) that corresponds to the best fit resolution given the passed in value and the 'closest' specification.
number
Method: initResolutions This method's responsibility is to set up the 'resolutions' array for the layer -- this array is what the layer will use to interface between the zoom levels of the map and the resolution display of the layer.
The user has several options that determine how the array is set up.
For a detailed explanation, see the following wiki from the openlayers.org homepage: http://trac.openlayers.org/wiki/SettingZoomLevels
APIMethod: mergeNewParams
Parameters: newParams - {Object}
Returns: redrawn: {Boolean} whether the layer was actually redrawn.
boolean
Method: moveByPx Move the layer based on pixel vector.
Parameters: dx - {Number} dy - {Number}
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 a bounds and make sure the data that that bounds requires is pre-loaded.
Parameters:
bounds - {
Method: onMapResize For singleTile layers, this will set a new tile size according to the dimensions of the map pane.
APIMethod: redraw Redraws the layer. Returns true if the layer was redrawn, false if not.
Parameters: force - {Boolean} Force redraw by adding random parameter.
Returns: {Boolean} The layer was redrawn.
boolean
Method: removeMap Called when the layer is removed from the map.
Parameters:
map - {
APIMethod: setIsBaseLayer
Parameters: isBaseLayer - {Boolean}
APIMethod: setName Sets the new layer name for this layer. Can trigger a changelayer event on the map.
Parameters: newName - {String} The new name.
APIMethod: setOpacity Sets the opacity for the entire layer (all images)
Parameters: opacity - {Float}
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 - {
APIMethod: setUrl
Parameters: newUrl - {String}
APIMethod: setVisibility Set the visibility flag for the layer and hide/show & redraw accordingly. Fire event unless otherwise specified
Note that visibility is no longer simply whether or not the layer's style.display is set to "block". Now we store a 'visibility' state property on the layer class, this allows us to remember whether or not we desire for a layer to be visible. In the case where the map's resolution is out of the layer's range, this desire may be subverted.
Parameters: visibility - {Boolean} Whether or not to display the layer (if in range)
Method: setZIndex
Parameters: zIndex - {Integer}
Constructor: OpenLayers.Layer.WMS Create a new WMS layer object
Examples:
The code below creates a simple WMS layer using the image/jpeg format. (code) var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", "http://wms.jpl.nasa.gov/wms.cgi", {layers: "modis,global_mosaic"}); (end) Note the 3rd argument (params). Properties added to this object will be added to the WMS GetMap requests used for this layer's tiles. The only mandatory parameter is "layers". Other common WMS params include "transparent", "styles" and "format". Note that the "srs" param will always be ignored. Instead, it will be derived from the baseLayer's or map's projection.
The code below creates a transparent WMS layer with additional options.
(code)
var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic",
"http://wms.jpl.nasa.gov/wms.cgi",
{
layers: "modis,global_mosaic",
transparent: true
}, {
opacity: 0.5,
singleTile: true
});
(end)
Note that by default, a WMS layer is configured as baseLayer. Setting
the "transparent" param to true will apply some magic (see
Parameters: name - {String} A name for the layer url - {String} Base url for the WMS (e.g. http://wms.jpl.nasa.gov/wms.cgi) params - {Object} An object with key/value pairs representing the GetMap query string parameters and parameter values. options - {Object} Hashtable of extra options to tag onto the layer. These options include all properties listed above, plus the ones inherited from superclasses.
The properties that are used for calculating resolutions information.
The layer's images have an alpha channel. Default is false.
If a layer's display should not be scale-based, this should be set to true. This will cause the layer, as an overlay, to always be 'active', by always returning true from the calculateInRange() function.
If not explicitly specified for a layer, its value will be determined on startup in initResolutions() based on whether or not any scale-specific properties have been set as options on the layer. If no scale-specific options have been set on the layer, we assume that it should always be in range.
Attribution string, displayed when an
Property: backBuffer {DOMElement} The back buffer.
Property: backBufferLonLat {Object} The top-left corner of the current back buffer. Includes lon and lat properties. This object is updated each time a back buffer is created.
Property: backBufferResolution {Number} The resolution of the current back buffer. This property is updated each time a back buffer is created.
Property: backBufferTimerId {Number} The id of the back buffer timer. This timer is used to delay the removal of the back buffer, thereby preventing flash effects caused by tile animation.
APIProperty: buffer {Integer} Used only when in gridded mode, this specifies the number of extra rows and columns 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.
APIProperty: className
{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
Note:
The displaying of tiles is not animated by default for single tile
layers - OpenLayers' default theme (style.css) includes this:
(code)
.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;
}
(end)
To animate tile displaying for any grid layer the following
CSS rule can be used:
(code)
.olTileImage {
-webkit-transition: opacity 0.2s linear;
-moz-transition: opacity 0.2s linear;
-o-transition: opacity 0.2s linear;
transition: opacity 0.2s linear;
}
(end)
In that case, to avoid flash effects,
Display the layer's name in the layer switcher. Default is true
Request map tiles that are completely outside of the max extent for this layer. Defaults to false.
Should the BBOX commas be encoded? The WMS spec says 'no', but some services want it that way. Default false.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
APIProperty: events
{
Register a listener for a particular event with the following syntax: (code) layer.events.register(type, obj, listener); (end)
Listeners will be called with a reference to an event object. The properties of this event depends on exactly what happened.
All event objects have at least the following properties: object - {Object} A reference to layer.events.object. element - {DOMElement} A reference to layer.events.element.
Supported map event types:
loadstart - Triggered when layer loading starts. When using a Vector
layer with a Fixed or BBOX strategy, the event object includes
a filter property holding the OpenLayers.Filter used when
calling read on the protocol.
loadend - Triggered when layer loading ends. When using a Vector layer
with a Fixed or BBOX strategy, the event object includes a
response property holding an OpenLayers.Protocol.Response object.
visibilitychanged - Triggered when the layer's visibility property is
changed, e.g. by turning the layer on or off in the layer switcher.
Note that the actual visibility of the layer can also change if it
gets out of range (see
Property: grid
{Array(Array(
Property: gridLayout {Object} Object containing properties tilelon, tilelat, startcol, startrow
Property: gridResolution {Number} The resolution of the current grid. Used for backbuffer and client zoom. This property is updated every time the grid is initialized.
Determines the width (in pixels) of the gutter around image tiles to ignore. By setting this property to a non-zero value, images will be requested that are wider and taller than the tile size by a value of 2 x gutter. This allows artifacts of rendering at tile edges to be ignored. Set a gutter value that is equal to half the size of the widest symbol that needs to be displayed. Defaults to zero. Non-tiled layers always have zero gutter.
For layers with a gutter, the image is larger than the tile by twice the gutter in each dimension.
The current map resolution is within the layer's min/max
range. This is set in
Default is true for WMS layer
Property: loading {Boolean} Indicates if tiles are being loaded.
This variable is set when the layer is added to the map, via the accessor function setMap()
The maximum extent for the layer. Defaults to null.
Default max is 360 deg / 256 px, which corresponds to
zoom level 0 on gmaps. Specify a different value in the layer
options if you are not using the default
This object can be used to store additional information on a layer object.
The minimum extent for the layer. Defaults to null.
If true, the image format will not be automagicaly switched from image/jpeg to image/png or image/gif when using TRANSPARENT=TRUE. Also isBaseLayer will not changed by the constructor. Default false.
APIProperty: numLoadingTiles {Integer} How many tiles are still loading?
The layer's opacity. Float number between 0.0 and 1.0.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
Property: params {Object} Hashtable of key/value parameters
Specifies the projection of the layer. Can be set in the layer options. If not specified in the layer options, it is set to the default projection specified in the map, when the layer is added to the map. Projection along with default maxExtent and resolutions are set automatically with commercial baselayers in EPSG:3857, such as Google, Bing and OpenStreetMap, and do not need to be specified. Otherwise, if specifying projection, also set maxExtent, maxResolution or resolutions as appropriate. When using vector layers with strategies, layer projection should be set to the projection of the source data if that is different from the map default.
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. Default value is 1.5.
APIProperty: removeBackBufferDelay
{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
APIProperty: reproject Deprecated. See http://docs.openlayers.org/library/spherical_mercator.html for information on the replacement for this functionality. {Boolean} Whether layer should reproject itself based on base layer locations. This allows reprojection onto commercial layers. Default is false: Most layers can't reproject, but layers which can create non-square geographic pixels can, like WMS.
A list of map resolutions (map units per pixel) in descending order. If this is not set in the layer constructor, it will be set based on other resolution related properties (maxExtent, maxResolution, maxScale, etc.).
Property: rowSign {Number} 1 for grids starting at the top, -1 for grids starting at the bottom. This is used for several grid index and offset calculations.
An array of map scales in descending order. The values in the
array correspond to the map scale denominator. Note that these
values only make sense if the display (monitor) resolution of the
client is correctly guessed by whomever is configuring the
application. In addition, the units property must also be set.
Use
Property: serverResolutions {Array(Number}} This property is documented in subclasses as an API property.
APIProperty: singleTile {Boolean} Moves the layer into single-tile mode, meaning that one tile will be loaded. The tile's size will be determined by the 'ratio' property. When the tile is dragged such that it does not cover the entire viewport, it is reloaded.
APIProperty: tileClass
{
APIProperty: tileOptions
{Object} optional configuration options for
APIProperty: tileOrigin
{
null
.
Property: tileOriginCorner
{String} If the
APIProperty: tileSize
{
APIProperty: transitionEffect {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.
Property: transitionendEvents {Array} Event names for transitionend
The layer map units. Defaults to null. Possible values are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. Normally taken from the projection. Only required if both map and layers do not define a projection, or if they define a projection which does not define units.
Property: url {Array(String) or String} This is either an array of url strings or a single url string.
The layer should be displayed in the map. Default is true.
Wraps the world at the international dateline, so the map can be panned infinitely in longitudinal direction. Only use this on the base layer, and only if the layer's maxExtent equals the world bounds.
Keys in this object are EPSG codes for which the axis order
is to be reversed (yx instead of xy, LatLon instead of LonLat), with
true as value. This is only relevant for WMS versions >= 1.3.0, and
only if yx is not set in
APIMethod: addOptions
Parameters: 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.
APIMethod: addTile Create a tile, initialize it, and add it to the layer div.
Parameters
bounds - {
Returns:
{
Method: adjustBounds This function will take a bounds, and if wrapDateLine option is set on the layer, it will return a bounds which is wrapped around the world. We do not wrap for bounds which cross the maxExtent.left/right, only bounds which are entirely to the left or entirely to the right.
Parameters:
bounds - {
APIMethod: calculateInRange
Returns: {Boolean} The layer is displayable at the current map's current resolution. Note that if 'alwaysInRange' is true for the layer, this function will always return true.
boolean
Method: calculateResolutions Calculate resolutions based on the provided properties.
Parameters: props - {Object} Properties
Returns: {Array({Number})} Array of resolutions.
Array<number>
Create a clone of this layer
APIMethod: destroy Deconstruct the layer and clear the grid.
APIMethod: display Hide or show the Layer. This is designed to be used internally, and is not generally the way to enable or disable the layer. For that, use the setVisibility function instead..
Parameters: display - {Boolean}
APIMethod: getExtent
Returns:
{
Combine the layer's url with its params and these newParams.
Add the SRS parameter from projection -- this is probably more eloquently done via a setProjection() method, but this works for now and always.
string
APIMethod: getLonLatFromViewPortPx
Parameters:
viewPortPx - {
Returns:
{
APIMethod: getResolution
Returns: {Float} The currently selected resolution of the map, taken from the resolutions array, indexed by current zoom level.
number
APIMethod: getResolutionForZoom
Parameters: zoom - {Float}
Returns: {Float} A suitable resolution for the specified zoom.
number
APIMethod: getTileBounds Returns The tile bounds for a layer given a pixel location.
Parameters:
viewPortPx - {
Returns:
{
APIMethod: getTilesBounds Return the bounds of the tile grid.
Returns:
{
Return a GetMap query string for this layer
string
APIMethod: getViewPortPxFromLonLat Returns a pixel location given a map location. This method will return fractional pixel values.
Parameters:
lonlat - {
Returns:
{
APIMethod: getVisibility
Returns: {Boolean} The layer should be displayed (if in range).
boolean
Method: getZIndex
Returns: {Integer} the z-index of this layer
number
APIMethod: getZoomForExtent
Parameters:
extent - {
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) for the passed-in extent. We do this by calculating the ideal resolution for the given extent (based on the map size) and then calling getZoomForResolution(), passing along the 'closest' parameter.
number
APIMethod: getZoomForResolution
Parameters: resolution - {Float} closest - {Boolean} Find the zoom level that corresponds to the absolute closest resolution, which may result in a zoom whose corresponding resolution is actually smaller than we would have desired (if this is being called from a getZoomForExtent() call, then this means that the returned zoom index might not actually contain the entire extent specified... but it'll be close). Default is false.
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) that corresponds to the best fit resolution given the passed in value and the 'closest' specification.
number
Method: initResolutions This method's responsibility is to set up the 'resolutions' array for the layer -- this array is what the layer will use to interface between the zoom levels of the map and the resolution display of the layer.
The user has several options that determine how the array is set up.
For a detailed explanation, see the following wiki from the openlayers.org homepage: http://trac.openlayers.org/wiki/SettingZoomLevels
Catch changeParams and uppercase the new params to be merged in before calling changeParams on the super class. Once params have been changed, the tiles will be reloaded with the new parameters.
boolean
Method: moveByPx Move the layer based on pixel vector.
Parameters: dx - {Number} dy - {Number}
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 a bounds and make sure the data that that bounds requires is pre-loaded.
Parameters:
bounds - {
Method: onMapResize For singleTile layers, this will set a new tile size according to the dimensions of the map pane.
APIMethod: redraw Redraws the layer. Returns true if the layer was redrawn, false if not.
Parameters: force - {Boolean} Force redraw by adding random parameter.
Returns: {Boolean} The layer was redrawn.
boolean
Method: removeMap Called when the layer is removed from the map.
Parameters:
map - {
Returns true if the axis order is reversed for the WMS version and projection of the layer.
boolean
APIMethod: setIsBaseLayer
Parameters: isBaseLayer - {Boolean}
Method: setMap
Parameters:
map - {
APIMethod: setName Sets the new layer name for this layer. Can trigger a changelayer event on the map.
Parameters: newName - {String} The new name.
APIMethod: setOpacity Sets the opacity for the entire layer (all images)
Parameters: opacity - {Float}
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 - {
APIMethod: setUrl
Parameters: newUrl - {String}
APIMethod: setVisibility Set the visibility flag for the layer and hide/show & redraw accordingly. Fire event unless otherwise specified
Note that visibility is no longer simply whether or not the layer's style.display is set to "block". Now we store a 'visibility' state property on the layer class, this allows us to remember whether or not we desire for a layer to be visible. In the case where the map's resolution is out of the layer's range, this desire may be subverted.
Parameters: visibility - {Boolean} Whether or not to display the layer (if in range)
Method: setZIndex
Parameters: zIndex - {Integer}
Constructor: OpenLayers.Layer.XYZ
Parameters: name - {String} url - {String} options - {Object} Hashtable of extra options to tag onto the layer
The properties that are used for calculating resolutions information.
The layer's images have an alpha channel. Default is false.
If a layer's display should not be scale-based, this should be set to true. This will cause the layer, as an overlay, to always be 'active', by always returning true from the calculateInRange() function.
If not explicitly specified for a layer, its value will be determined on startup in initResolutions() based on whether or not any scale-specific properties have been set as options on the layer. If no scale-specific options have been set on the layer, we assume that it should always be in range.
Attribution string, displayed when an
Property: backBuffer {DOMElement} The back buffer.
Property: backBufferLonLat {Object} The top-left corner of the current back buffer. Includes lon and lat properties. This object is updated each time a back buffer is created.
Property: backBufferResolution {Number} The resolution of the current back buffer. This property is updated each time a back buffer is created.
Property: backBufferTimerId {Number} The id of the back buffer timer. This timer is used to delay the removal of the back buffer, thereby preventing flash effects caused by tile animation.
APIProperty: buffer {Integer} Used only when in gridded mode, this specifies the number of extra rows and columns 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.
APIProperty: className
{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
Note:
The displaying of tiles is not animated by default for single tile
layers - OpenLayers' default theme (style.css) includes this:
(code)
.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;
}
(end)
To animate tile displaying for any grid layer the following
CSS rule can be used:
(code)
.olTileImage {
-webkit-transition: opacity 0.2s linear;
-moz-transition: opacity 0.2s linear;
-o-transition: opacity 0.2s linear;
transition: opacity 0.2s linear;
}
(end)
In that case, to avoid flash effects,
Display the layer's name in the layer switcher. Default is true
Request map tiles that are completely outside of the max extent for this layer. Defaults to false.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
APIProperty: events
{
Register a listener for a particular event with the following syntax: (code) layer.events.register(type, obj, listener); (end)
Listeners will be called with a reference to an event object. The properties of this event depends on exactly what happened.
All event objects have at least the following properties: object - {Object} A reference to layer.events.object. element - {DOMElement} A reference to layer.events.element.
Supported map event types:
loadstart - Triggered when layer loading starts. When using a Vector
layer with a Fixed or BBOX strategy, the event object includes
a filter property holding the OpenLayers.Filter used when
calling read on the protocol.
loadend - Triggered when layer loading ends. When using a Vector layer
with a Fixed or BBOX strategy, the event object includes a
response property holding an OpenLayers.Protocol.Response object.
visibilitychanged - Triggered when the layer's visibility property is
changed, e.g. by turning the layer on or off in the layer switcher.
Note that the actual visibility of the layer can also change if it
gets out of range (see
Property: grid
{Array(Array(
Property: gridLayout {Object} Object containing properties tilelon, tilelat, startcol, startrow
Property: gridResolution {Number} The resolution of the current grid. Used for backbuffer and client zoom. This property is updated every time the grid is initialized.
Determines the width (in pixels) of the gutter around image tiles to ignore. By setting this property to a non-zero value, images will be requested that are wider and taller than the tile size by a value of 2 x gutter. This allows artifacts of rendering at tile edges to be ignored. Set a gutter value that is equal to half the size of the widest symbol that needs to be displayed. Defaults to zero. Non-tiled layers always have zero gutter.
For layers with a gutter, the image is larger than the tile by twice the gutter in each dimension.
The current map resolution is within the layer's min/max
range. This is set in
APIProperty: isBaseLayer Default is true, as this is designed to be a base tile source.
Property: loading {Boolean} Indicates if tiles are being loaded.
This variable is set when the layer is added to the map, via the accessor function setMap()
The maximum extent for the layer. Defaults to null.
Default max is 360 deg / 256 px, which corresponds to
zoom level 0 on gmaps. Specify a different value in the layer
options if you are not using the default
This object can be used to store additional information on a layer object.
The minimum extent for the layer. Defaults to null.
APIProperty: numLoadingTiles {Integer} How many tiles are still loading?
The layer's opacity. Float number between 0.0 and 1.0.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
Property: params {Object} Hashtable of key/value parameters
Specifies the projection of the layer. Can be set in the layer options. If not specified in the layer options, it is set to the default projection specified in the map, when the layer is added to the map. Projection along with default maxExtent and resolutions are set automatically with commercial baselayers in EPSG:3857, such as Google, Bing and OpenStreetMap, and do not need to be specified. Otherwise, if specifying projection, also set maxExtent, maxResolution or resolutions as appropriate. When using vector layers with strategies, layer projection should be set to the projection of the source data if that is different from the map default.
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. Default value is 1.5.
APIProperty: removeBackBufferDelay
{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
APIProperty: reproject Deprecated. See http://docs.openlayers.org/library/spherical_mercator.html for information on the replacement for this functionality. {Boolean} Whether layer should reproject itself based on base layer locations. This allows reprojection onto commercial layers. Default is false: Most layers can't reproject, but layers which can create non-square geographic pixels can, like WMS.
A list of map resolutions (map units per pixel) in descending order. If this is not set in the layer constructor, it will be set based on other resolution related properties (maxExtent, maxResolution, maxScale, etc.).
Property: rowSign {Number} 1 for grids starting at the top, -1 for grids starting at the bottom. This is used for several grid index and offset calculations.
An array of map scales in descending order. The values in the
array correspond to the map scale denominator. Note that these
values only make sense if the display (monitor) resolution of the
client is correctly guessed by whomever is configuring the
application. In addition, the units property must also be set.
Use
APIProperty: serverResolutions
{Array} A list of all resolutions available on the server. Only set this
property if the map resolutions differ from the server. This
property serves two purposes. (a)
APIProperty: singleTile {Boolean} Moves the layer into single-tile mode, meaning that one tile will be loaded. The tile's size will be determined by the 'ratio' property. When the tile is dragged such that it does not cover the entire viewport, it is reloaded.
APIProperty: sphericalMercator Whether the tile extents should be set to the defaults for spherical mercator. Useful for things like OpenStreetMap. Default is false, except for the OSM subclass.
APIProperty: tileClass
{
APIProperty: tileOptions
{Object} optional configuration options for
APIProperty: tileOrigin
{
null
.
Property: tileOriginCorner
{String} If the
APIProperty: tileSize
{
APIProperty: transitionEffect {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.
Property: transitionendEvents {Array} Event names for transitionend
The layer map units. Defaults to null. Possible values are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. Normally taken from the projection. Only required if both map and layers do not define a projection, or if they define a projection which does not define units.
Property: url {Array(String) or String} This is either an array of url strings or a single url string.
The layer should be displayed in the map. Default is true.
Wraps the world at the international dateline, so the map can be panned infinitely in longitudinal direction. Only use this on the base layer, and only if the layer's maxExtent equals the world bounds.
APIProperty: zoomOffset
{Number} If your cache has more zoom levels than you want to provide
access to with this layer, supply a zoomOffset. This zoom offset
is added to the current map zoom level to determine the level
for a requested tile. For example, if you supply a zoomOffset
of 3, when the map is at the zoom 0, tiles will be requested from
level 3 of your cache. Default is 0 (assumes cache level and map
zoom are equivalent). Using
APIMethod: addOptions
Parameters: 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.
APIMethod: addTile Create a tile, initialize it, and add it to the layer div.
Parameters
bounds - {
Returns:
{
Method: adjustBounds This function will take a bounds, and if wrapDateLine option is set on the layer, it will return a bounds which is wrapped around the world. We do not wrap for bounds which cross the maxExtent.left/right, only bounds which are entirely to the left or entirely to the right.
Parameters:
bounds - {
APIMethod: calculateInRange
Returns: {Boolean} The layer is displayable at the current map's current resolution. Note that if 'alwaysInRange' is true for the layer, this function will always return true.
boolean
Method: calculateResolutions Calculate resolutions based on the provided properties.
Parameters: props - {Object} Properties
Returns: {Array({Number})} Array of resolutions.
Array<number>
APIMethod: clone Create a clone of this layer
Parameters: obj - {Object} Is this ever used?
Returns:
{
APIMethod: destroy Deconstruct the layer and clear the grid.
APIMethod: display Hide or show the Layer. This is designed to be used internally, and is not generally the way to enable or disable the layer. For that, use the setVisibility function instead..
Parameters: display - {Boolean}
APIMethod: getExtent
Returns:
{
Method: getFullRequestString Combine url with layer's params and these newParams.
does checking on the serverPath variable, allowing for cases when it is supplied with trailing ? or &, as well as cases where not.
return in formatted string like this: "server?key1=value1&key2=value2&key3=value3"
WARNING: The altUrl parameter is deprecated and will be removed in 3.0.
Parameters: newParams - {Object} altUrl - {String} Use this as the url instead of the layer's url
Returns: {String}
string
APIMethod: getLonLatFromViewPortPx
Parameters:
viewPortPx - {
Returns:
{
APIMethod: getResolution
Returns: {Float} The currently selected resolution of the map, taken from the resolutions array, indexed by current zoom level.
number
APIMethod: getResolutionForZoom
Parameters: zoom - {Float}
Returns: {Float} A suitable resolution for the specified zoom.
number
APIMethod: getTileBounds Returns The tile bounds for a layer given a pixel location.
Parameters:
viewPortPx - {
Returns:
{
APIMethod: getTilesBounds Return the bounds of the tile grid.
Returns:
{
Method: getURL
Parameters:
bounds - {
Returns: {String} A string with the layer's url and parameters and also the passed-in bounds and appropriate tile size specified as parameters
string
APIMethod: getViewPortPxFromLonLat Returns a pixel location given a map location. This method will return fractional pixel values.
Parameters:
lonlat - {
Returns:
{
APIMethod: getVisibility
Returns: {Boolean} The layer should be displayed (if in range).
boolean
Method: getXYZ Calculates x, y and z for the given bounds.
Parameters:
bounds - {
Returns: {Object} - an object with x, y and z properties.
{ x: number; y: number; z: number; }
Method: getZIndex
Returns: {Integer} the z-index of this layer
number
APIMethod: getZoomForExtent
Parameters:
extent - {
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) for the passed-in extent. We do this by calculating the ideal resolution for the given extent (based on the map size) and then calling getZoomForResolution(), passing along the 'closest' parameter.
number
APIMethod: getZoomForResolution
Parameters: resolution - {Float} closest - {Boolean} Find the zoom level that corresponds to the absolute closest resolution, which may result in a zoom whose corresponding resolution is actually smaller than we would have desired (if this is being called from a getZoomForExtent() call, then this means that the returned zoom index might not actually contain the entire extent specified... but it'll be close). Default is false.
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) that corresponds to the best fit resolution given the passed in value and the 'closest' specification.
number
Method: initResolutions This method's responsibility is to set up the 'resolutions' array for the layer -- this array is what the layer will use to interface between the zoom levels of the map and the resolution display of the layer.
The user has several options that determine how the array is set up.
For a detailed explanation, see the following wiki from the openlayers.org homepage: http://trac.openlayers.org/wiki/SettingZoomLevels
APIMethod: mergeNewParams
Parameters: newParams - {Object}
Returns: redrawn: {Boolean} whether the layer was actually redrawn.
boolean
Method: moveByPx Move the layer based on pixel vector.
Parameters: dx - {Number} dy - {Number}
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 a bounds and make sure the data that that bounds requires is pre-loaded.
Parameters:
bounds - {
Method: onMapResize For singleTile layers, this will set a new tile size according to the dimensions of the map pane.
APIMethod: redraw Redraws the layer. Returns true if the layer was redrawn, false if not.
Parameters: force - {Boolean} Force redraw by adding random parameter.
Returns: {Boolean} The layer was redrawn.
boolean
Method: removeMap Called when the layer is removed from the map.
Parameters:
map - {
APIMethod: setIsBaseLayer
Parameters: isBaseLayer - {Boolean}
APIMethod: setName Sets the new layer name for this layer. Can trigger a changelayer event on the map.
Parameters: newName - {String} The new name.
APIMethod: setOpacity Sets the opacity for the entire layer (all images)
Parameters: opacity - {Float}
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 - {
APIMethod: setUrl
Parameters: newUrl - {String}
APIMethod: setVisibility Set the visibility flag for the layer and hide/show & redraw accordingly. Fire event unless otherwise specified
Note that visibility is no longer simply whether or not the layer's style.display is set to "block". Now we store a 'visibility' state property on the layer class, this allows us to remember whether or not we desire for a layer to be visible. In the case where the map's resolution is out of the layer's range, this desire may be subverted.
Parameters: visibility - {Boolean} Whether or not to display the layer (if in range)
Method: setZIndex
Parameters: zIndex - {Integer}
Constructor: OpenLayers.Layer
Parameters: name - {String} The layer name options - {Object} Hashtable of extra options to tag onto the layer
The properties that are used for calculating resolutions information.
The layer's images have an alpha channel. Default is false.
If a layer's display should not be scale-based, this should be set to true. This will cause the layer, as an overlay, to always be 'active', by always returning true from the calculateInRange() function.
If not explicitly specified for a layer, its value will be determined on startup in initResolutions() based on whether or not any scale-specific properties have been set as options on the layer. If no scale-specific options have been set on the layer, we assume that it should always be in range.
Attribution string, displayed when an
Display the layer's name in the layer switcher. Default is true
Request map tiles that are completely outside of the max extent for this layer. Defaults to false.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
APIProperty: events
{
Register a listener for a particular event with the following syntax: (code) layer.events.register(type, obj, listener); (end)
Listeners will be called with a reference to an event object. The properties of this event depends on exactly what happened.
All event objects have at least the following properties: object - {Object} A reference to layer.events.object. element - {DOMElement} A reference to layer.events.element.
Supported map event types:
loadstart - Triggered when layer loading starts. When using a Vector
layer with a Fixed or BBOX strategy, the event object includes
a filter property holding the OpenLayers.Filter used when
calling read on the protocol.
loadend - Triggered when layer loading ends. When using a Vector layer
with a Fixed or BBOX strategy, the event object includes a
response property holding an OpenLayers.Protocol.Response object.
visibilitychanged - Triggered when the layer's visibility property is
changed, e.g. by turning the layer on or off in the layer switcher.
Note that the actual visibility of the layer can also change if it
gets out of range (see
Determines the width (in pixels) of the gutter around image tiles to ignore. By setting this property to a non-zero value, images will be requested that are wider and taller than the tile size by a value of 2 x gutter. This allows artifacts of rendering at tile edges to be ignored. Set a gutter value that is equal to half the size of the widest symbol that needs to be displayed. Defaults to zero. Non-tiled layers always have zero gutter.
For layers with a gutter, the image is larger than the tile by twice the gutter in each dimension.
The current map resolution is within the layer's min/max
range. This is set in
Whether or not the layer is a base layer. This should be set individually by all subclasses. Default is false
This variable is set when the layer is added to the map, via the accessor function setMap()
The maximum extent for the layer. Defaults to null.
Default max is 360 deg / 256 px, which corresponds to
zoom level 0 on gmaps. Specify a different value in the layer
options if you are not using the default
This object can be used to store additional information on a layer object.
The minimum extent for the layer. Defaults to null.
The layer's opacity. Float number between 0.0 and 1.0.
An optional object whose properties will be set on the layer. Any of the layer properties can be set as a property of the options object and sent to the constructor when the layer is created.
Specifies the projection of the layer. Can be set in the layer options. If not specified in the layer options, it is set to the default projection specified in the map, when the layer is added to the map. Projection along with default maxExtent and resolutions are set automatically with commercial baselayers in EPSG:3857, such as Google, Bing and OpenStreetMap, and do not need to be specified. Otherwise, if specifying projection, also set maxExtent, maxResolution or resolutions as appropriate. When using vector layers with strategies, layer projection should be set to the projection of the source data if that is different from the map default.
A list of map resolutions (map units per pixel) in descending order. If this is not set in the layer constructor, it will be set based on other resolution related properties (maxExtent, maxResolution, maxScale, etc.).
An array of map scales in descending order. The values in the
array correspond to the map scale denominator. Note that these
values only make sense if the display (monitor) resolution of the
client is correctly guessed by whomever is configuring the
application. In addition, the units property must also be set.
Use
The layer map units. Defaults to null. Possible values are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. Normally taken from the projection. Only required if both map and layers do not define a projection, or if they define a projection which does not define units.
The layer should be displayed in the map. Default is true.
Wraps the world at the international dateline, so the map can be panned infinitely in longitudinal direction. Only use this on the base layer, and only if the layer's maxExtent equals the world bounds.
APIMethod: addOptions
Parameters: 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.
Method: adjustBounds This function will take a bounds, and if wrapDateLine option is set on the layer, it will return a bounds which is wrapped around the world. We do not wrap for bounds which cross the maxExtent.left/right, only bounds which are entirely to the left or entirely to the right.
Parameters:
bounds - {
Method: afterAdd Called at the end of the map.addLayer sequence. At this point, the map will have a base layer. To be overridden by subclasses.
APIMethod: calculateInRange
Returns: {Boolean} The layer is displayable at the current map's current resolution. Note that if 'alwaysInRange' is true for the layer, this function will always return true.
boolean
Method: calculateResolutions Calculate resolutions based on the provided properties.
Parameters: props - {Object} Properties
Returns: {Array({Number})} Array of resolutions.
Array<number>
Method: clone
Parameters:
obj - {
Returns:
{
Method: destroy Destroy is a destructor: this is to alleviate cyclic references which the Javascript garbage cleaner can not take care of on its own.
Parameters: setNewBaseLayer - {Boolean} Set a new base layer when this layer has been destroyed. Default is true.
APIMethod: display Hide or show the Layer. This is designed to be used internally, and is not generally the way to enable or disable the layer. For that, use the setVisibility function instead..
Parameters: display - {Boolean}
Method: getDataExtent Calculates the max extent which includes all of the data for the layer. This function is to be implemented by subclasses.
Returns:
{
APIMethod: getExtent
Returns:
{
APIMethod: getImageSize
Parameters:
bounds - {
Returns:
{
APIMethod: getLonLatFromViewPortPx
Parameters:
viewPortPx - {
Returns:
{
Method: getOptions Extracts an object from the layer with the properties that were set as options, but updates them with the values currently set on the instance.
Returns:
{Object} the
APIMethod: getResolution
Returns: {Float} The currently selected resolution of the map, taken from the resolutions array, indexed by current zoom level.
number
APIMethod: getResolutionForZoom
Parameters: zoom - {Float}
Returns: {Float} A suitable resolution for the specified zoom.
number
APIMethod: getViewPortPxFromLonLat Returns a pixel location given a map location. This method will return fractional pixel values.
Parameters:
lonlat - {
Returns:
{
APIMethod: getVisibility
Returns: {Boolean} The layer should be displayed (if in range).
boolean
Method: getZIndex
Returns: {Integer} the z-index of this layer
number
APIMethod: getZoomForExtent
Parameters:
extent - {
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) for the passed-in extent. We do this by calculating the ideal resolution for the given extent (based on the map size) and then calling getZoomForResolution(), passing along the 'closest' parameter.
number
APIMethod: getZoomForResolution
Parameters: resolution - {Float} closest - {Boolean} Find the zoom level that corresponds to the absolute closest resolution, which may result in a zoom whose corresponding resolution is actually smaller than we would have desired (if this is being called from a getZoomForExtent() call, then this means that the returned zoom index might not actually contain the entire extent specified... but it'll be close). Default is false.
Returns: {Integer} The index of the zoomLevel (entry in the resolutions array) that corresponds to the best fit resolution given the passed in value and the 'closest' specification.
number
Method: initResolutions This method's responsibility is to set up the 'resolutions' array for the layer -- this array is what the layer will use to interface between the zoom levels of the map and the resolution display of the layer.
The user has several options that determine how the array is set up.
For a detailed explanation, see the following wiki from the openlayers.org homepage: http://trac.openlayers.org/wiki/SettingZoomLevels
Method: moveByPx Move the layer based on pixel vector. To be implemented by subclasses.
Parameters: dx - {Number} The x coord of the displacement vector. dy - {Number} The y coord of the displacement vector.
Method: moveTo
Parameters:
bounds - {
This function can be implemented by subclasses
APIMethod: redraw Redraws the layer. Returns true if the layer was redrawn, false if not.
Returns: {Boolean} The layer was redrawn.
APIMethod: removeMap Just as setMap() allows each layer the possibility to take a personalized action on being added to the map, removeMap() allows each layer to take a personalized action on being removed from it. For now, this will be mostly unused, except for the EventPane layer, which needs this hook so that it can remove the special invisible pane.
Parameters:
map - {
Method: resolutionsFromScales Derive resolutions from scales.
Parameters: scales - {Array(Number)} Scales
Returns {Array(Number)} Resolutions
Array<number>
APIMethod: setIsBaseLayer
Parameters: isBaseLayer - {Boolean}
Method: setMap Set the map property for the layer. This is done through an accessor so that subclasses can override this and take special action once they have their map variable set.
Here we take care to bring over any of the necessary default properties from the map.
Parameters:
map - {
APIMethod: setName Sets the new layer name for this layer. Can trigger a changelayer event on the map.
Parameters: newName - {String} The new name.
APIMethod: setOpacity Sets the opacity for the entire layer (all images)
Parameters: opacity - {Float}
APIMethod: setTileSize Set the tile size based on the map size. This also sets layer.imageSize or use by Tile.Image.
Parameters:
size - {
APIMethod: setVisibility Set the visibility flag for the layer and hide/show & redraw accordingly. Fire event unless otherwise specified
Note that visibility is no longer simply whether or not the layer's style.display is set to "block". Now we store a 'visibility' state property on the layer class, this allows us to remember whether or not we desire for a layer to be visible. In the case where the map's resolution is out of the layer's range, this desire may be subverted.
Parameters: visibility - {Boolean} Whether or not to display the layer (if in range)
Method: setZIndex
Parameters: zIndex - {Integer}