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 <OpenLayers.Control.Attribution> has been added to the map.
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 {<OpenLayers.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(<OpenLayers.Tile>))} This is an array of rows, each row is an array of tiles.
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 <OpenLayers.Map.setCenter> whenever the zoom changes.
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 <OpenLayers.Map.tileSize> and displaying the whole world.
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.
The properties that are used for calculating resolutions information.
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 {<OpenLayers.Tile>} The tile class to use for this layer. Defaults is OpenLayers.Tile.Image.
APIProperty: tileOptions {Object} optional configuration options for <OpenLayers.Tile> instances created by this Layer, if supported by the tile class.
APIProperty: tileOrigin
{<OpenLayers.LonLat>} Optional origin for aligning the grid of tiles.
If provided, requests for tiles at all resolutions will be aligned
with this location (no tiles shall overlap this location). If
not provided, the grid of tiles will be aligned with the layer's
null.
Property: tileOriginCorner
{String} If the
APIProperty: tileSize {<OpenLayers.Size>}
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 <OpenLayers.Projection.defaults> for the used projection.
StaticCLASS_StaticURL_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.
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 - {<OpenLayers.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.
Method: calculateResolutions Calculate resolutions based on the provided properties.
Parameters: props - {Object} Properties
Returns: {Array({Number})} Array of resolutions.
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: {<OpenLayers.Bounds>} A Bounds object which represents the lon/lat bounds of the current viewPort.
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.
APIMethod: getImageSize
Parameters: bounds - {<OpenLayers.Bounds>} optional tile bounds, can be used by subclasses that have to deal with different tile sizes at the layer extent edges (e.g. Zoomify)
Returns: {<OpenLayers.Size>} The size that the image should be, taking into account gutters.
APIMethod: getLonLatFromViewPortPx
Parameters: viewPortPx - {<OpenLayers.Pixel>|Object} An OpenLayers.Pixel or an object with a 'x' and 'y' properties.
Returns: {<OpenLayers.LonLat>} An OpenLayers.LonLat which is the passed-in view port <OpenLayers.Pixel>, translated into lon/lat by the layer.
APIMethod: getResolution
Returns: {Float} The currently selected resolution of the map, taken from the resolutions array, indexed by current zoom level.
APIMethod: getResolutionForZoom
Parameters: zoom - {Float}
Returns: {Float} A suitable resolution for the specified zoom.
APIMethod: getTilesBounds Return the bounds of the tile grid.
Returns: {<OpenLayers.Bounds>} A Bounds object representing the bounds of all the currently loaded tiles (including those partially or not at all seen onscreen).
APIMethod: getViewPortPxFromLonLat Returns a pixel location given a map location. This method will return fractional pixel values.
Parameters: lonlat - {<OpenLayers.LonLat>|Object} An OpenLayers.LonLat or an object with a 'lon' and 'lat' properties.
Returns: {<OpenLayers.Pixel>} An <OpenLayers.Pixel> which is the passed-in lonlat translated into view port pixels.
APIMethod: getVisibility
Returns: {Boolean} The layer should be displayed (if in range).
Method: getZIndex
Returns: {Integer} the z-index of this layer
APIMethod: getZoomForExtent
Parameters: extent - {<OpenLayers.Bounds>} closest - {Boolean} Find the zoom level that most closely fits the specified bounds. Note that this may result in a zoom that does not exactly contain the entire extent. Default is false.
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.
Optionalclosest: booleanAPIMethod: 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.
Optionalclosest: booleanMethod: 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.
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 - {<OpenLayers.Bounds>} zoomChanged - {Boolean} dragging - {Boolean}
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.
Optionalforce: booleanMethod: removeBackBuffer Remove back buffer from DOM.
Method: removeMap Called when the layer is removed from the map.
Parameters: map - {<OpenLayers.Map>} The map.
Returns true if the axis order is reversed for the WMS version and projection of the layer.
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 - {<OpenLayers.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).
The default image format changes from image/jpeg to image/png, and the
layer is not configured as baseLayer.
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.