OpenLayers

Returns

{Boolean} The passed-in bounds object has the same left, right, top, bottom components as this. Note that if bounds passed in is null, returns false.

scale

scale: function( ratio,
origin )

Scales the bounds around a pixel or lonlat. Note that the new bounds may return non-integer properties, even if a pixel is passed.

Parameters

ratio	{Float}
origin	{OpenLayers.Pixel or OpenLayers.LonLat} Default is center.

Returns

{<OpenLayers.Bound>} A new bounds that is scaled by ratio from origin.

oppositeQuadrant

OpenLayers.Bounds.oppositeQuadrant = function( quadrant )

Get the opposite quadrant for a given quadrant string.

Parameters

quadrant

{String} two character quadrant shortstring

Returns

{String} The opposing quadrant (“br” “tr” “tl” “bl”). For Example, if you pass in “bl” it returns “tr”, if you pass in “br” it returns “tl”, etc.

OpenLayers. Element

Summary

Functions
hasClass	Tests if an element has the given CSS class name.
addClass	Add a CSS class name to an element.
removeClass	Remove a CSS class name from an element.
toggleClass	Remove a CSS class name from an element if it exists.

Functions

hasClass

hasClass: function( element,
name )

Tests if an element has the given CSS class name.

Parameters

element	{DOMElement} A DOM element node.
name	{String} The CSS class name to search for.

Returns

{Boolean} The element has the given class name.

addClass

addClass: function( element,
name )

Add a CSS class name to an element. Safe where element already has the class name.

Parameters

element	{DOMElement} A DOM element node.
name	{String} The CSS class name to add.

Returns

{DOMElement} The element.

removeClass

removeClass: function( element,
name )

Remove a CSS class name from an element. Safe where element does not have the class name.

Parameters

element	{DOMElement} A DOM element node.
name	{String} The CSS class name to remove.

Returns

{DOMElement} The element.

toggleClass

toggleClass: function( element,
name )

Remove a CSS class name from an element if it exists. Add the class name if it doesn’t exist.

Parameters

element	{DOMElement} A DOM element node.
name	{String} The CSS class name to toggle.

Returns

{DOMElement} The element.

OpenLayers. LonLat

This class represents a longitude and latitude pair

Summary

Functions
OpenLayers. LonLat	Create a new map location.
toString	Return a readable string version of the lonlat
fromString	Alternative constructor that builds a new OpenLayers.LonLat from a parameter string

Functions

OpenLayers. LonLat

Create a new map location.

Parameters

lon	{Number} The x-axis coordinate in map units. If your map is in a geographic projection, this will be the Longitude. Otherwise, it will be the x coordinate of the map location in your map units.
lat	{Number} The y-axis coordinate in map units. If your map is in a geographic projection, this will be the Latitude. Otherwise, it will be the y coordinate of the map location in your map units.

toString

toString:function()

Return a readable string version of the lonlat

Returns

{String} String representation of OpenLayers.LonLat object. (ex. ”lon=5,lat=42”)

fromString

OpenLayers.LonLat.fromString = function( str )

Alternative constructor that builds a new OpenLayers.LonLat from a parameter string

Parameters

str	{String} Comma-separated Lon,Lat coordinate string. (ex. <i>”5,40”</i>)

Returns

{OpenLayers.LonLat} New OpenLayers.LonLat object built from the passed-in String.

OpenLayers. Pixel

This class represents a screen coordinate, in x and y coordinates

Summary

Functions
OpenLayers. Pixel	Create a new OpenLayers.Pixel instance
toString	Cast this object into a string

Functions

OpenLayers. Pixel

Create a new OpenLayers.Pixel instance

Parameters

x	{Number} The x coordinate
y	{Number} The y coordinate

Returns

An instance of OpenLayers.Pixel

toString

toString:function()

Cast this object into a string

Returns

{String} The string representation of Pixel. ex: “x=200.4,y=242.2”

OpenLayers.Icon

The icon represents a graphical icon on the screen. Typically used in conjunction with a OpenLayers.Marker to represent markers on a screen.

An icon has a url, size and position. It also contains an offset which allows the center point to be represented correctly. This can be provided either as a fixed offset or a function provided to calculate the desired offset.

Summary

Properties
url	{String} image url
size	{OpenLayers.Size}
offset	{OpenLayers.Pixel} distance in pixels to offset the image when being rendered
calculateOffset	{OpenLayers.Pixel} Function to calculate the offset (based on the size)
imageDiv	{DOMElement}
px	{OpenLayers.Pixel}
Functions
OpenLayers.Icon	Creates an icon, which is an image tag in a div.
destroy	Nullify references and remove event listeners to prevent circular references and memory leaks
clone	{OpenLayers.Icon} A fresh copy of the icon.
setSize
setUrl
draw	Move the div to the given pixel.
erase	Erase the underlying image element.
setOpacity	Change the icon’s opacity
moveTo	move icon to passed in px.
display	Hide or show the icon

Properties

url

{String} image url

size

{OpenLayers.Size}

offset

{OpenLayers.Pixel} distance in pixels to offset the image when being rendered

calculateOffset

{OpenLayers.Pixel} Function to calculate the offset (based on the size)

imageDiv

{DOMElement}

px

Functions

OpenLayers.Icon

Creates an icon, which is an image tag in a div.

url	{String}
size	{OpenLayers.Size}
offset	{OpenLayers.Pixel}
calculateOffset	{Function}

destroy

destroy: function()

Nullify references and remove event listeners to prevent circular references and memory leaks

clone

clone: function()

Returns

{OpenLayers.Icon} A fresh copy of the icon.

setSize

setSize: function( size )

Parameters

size	{OpenLayers.Size}

setUrl

setUrl: function( url )

Parameters

url

{String}

draw

draw: function( px )

Move the div to the given pixel.

Parameters

px	{OpenLayers.Pixel}

Returns

{DOMElement} A new DOM Image of this icon set at the location passed-in

erase

erase: function()

Erase the underlying image element.

setOpacity

setOpacity: function( opacity )

Change the icon’s opacity

Parameters

opacity

{float}

moveTo

moveTo: function ( px )

move icon to passed in px.

Parameters

px	{OpenLayers.Pixel}

display

display: function( display )

Hide or show the icon

Parameters

display

{Boolean}

OpenLayers. Popup

A popup is a small div that can opened and closed on the map. Typically opened in response to clicking on a marker. See OpenLayers.Marker. Popup’s don’t require their own layer and are added the the map using the <OpenLayers.Map.addPopup> method.

Example

popup = new OpenLayers.Popup("chicken",
                   new OpenLayers.LonLat(5,40),
                   new OpenLayers.Size(200,200),
                   "example popup",
                   true);

map.addPopup(popup);

Summary

Properties and Functions
events	{OpenLayers.Events} custom event manager
id	{String} the unique identifier assigned to this popup.
lonlat	{OpenLayers.LonLat} the position of this popup on the map
div	{DOMElement} the div that contains this popup.
contentSize	{OpenLayers.Size} the width and height of the content.
size	{OpenLayers.Size} the width and height of the popup.
contentHTML	{String} An HTML string for this popup to display.
backgroundColor	{String} the background color used by the popup.
opacity	{float} the opacity of this popup (between 0.0 and 1.0)
border	{String} the border size of the popup.
contentDiv	{DOMElement} a reference to the element that holds the content of the div.
groupDiv	{DOMElement} First and only child of ‘div’.
closeDiv	{DOMElement} the optional closer image
displayClass	{String} The CSS class of the popup.
contentDisplayClass	{String} The CSS class of the popup content div.
padding	{int or OpenLayers.Bounds} An extra opportunity to specify internal padding of the content div inside the popup.
disableFirefoxOverflowHack	{Boolean} The hack for overflow in Firefox causes all elements to be re-drawn, which causes Flash elements to be re-initialized, which is troublesome.
fixPadding	To be removed in 3.0, this function merely helps us to deal with the case where the user may have set an integer value for padding, instead of an OpenLayers.Bounds object.
map	{OpenLayers.Map} this gets set in Map.js when the popup is added to the map
OpenLayers. Popup	Create a popup.
destroy	nullify references to prevent circular references and memory leaks
draw	Constructs the elements that make up the popup.
updatePosition	if the popup has a lonlat and its map members set, then have it move itself to its proper position
moveTo
visible	{Boolean} Boolean indicating whether or not the popup is visible
toggle	Toggles visibility of the popup.
show	Makes the popup visible.
hide	Makes the popup invisible.
setSize	Used to adjust the size of the popup.
setBackgroundColor	Sets the background color of the popup.
setOpacity	Sets the opacity of the popup.
setBorder	Sets the border style of the popup.
setContentHTML	Allows the user to set the HTML content of the popup.
registerImageListeners	Called when an image contained by the popup loaded.
getContentDivPadding	Glorious, oh glorious hack in order to determine the css ‘padding’ of the contentDiv.
addCloseBox
panIntoView	Pans the map such that the popup is totaly viewable (if necessary)
registerEvents	Registers events on the popup.
onmousedown	When mouse goes down within the popup, make a note of it locally, and then do not propagate the mousedown (but do so safely so that user can select text inside)
onmousemove	If the drag was started within the popup, then do not propagate the mousemove (but do so safely so that user can select text inside)
onmouseup	When mouse comes up within the popup, after going down in it, reset the flag, and then (once again) do not propagate the event, but do so safely so that user can select text inside
onclick	Ignore clicks, but allowing default browser handling
onmouseout	When mouse goes out of the popup set the flag to false so that if they let go and then drag back in, we won’t be confused.
ondblclick	Ignore double-clicks, but allowing default browser handling

Properties and Functions

events

{OpenLayers.Events} custom event manager

id

{String} the unique identifier assigned to this popup.

lonlat

{OpenLayers.LonLat} the position of this popup on the map

div

{DOMElement} the div that contains this popup.

contentSize

{OpenLayers.Size} the width and height of the content.

size

{OpenLayers.Size} the width and height of the popup.

contentHTML

{String} An HTML string for this popup to display.

backgroundColor

{String} the background color used by the popup.

opacity

{float} the opacity of this popup (between 0.0 and 1.0)

border

{String} the border size of the popup. (eg 2px)

contentDiv

{DOMElement} a reference to the element that holds the content of the div.

groupDiv

{DOMElement} First and only child of ‘div’. The group Div contains the ‘contentDiv’ and the ‘closeDiv’.

closeDiv

{DOMElement} the optional closer image

displayClass

{String} The CSS class of the popup.

contentDisplayClass

{String} The CSS class of the popup content div.

padding

{int or OpenLayers.Bounds} An extra opportunity to specify internal padding of the content div inside the popup. This was originally confused with the css padding as specified in style.css’s ‘olPopupContent’ class. We would like to get rid of this altogether, except that it does come in handy for the framed and anchoredbubble popups, who need to maintain yet another barrier between their content and the outer border of the popup itself.

Note that in order to not break API, we must continue to support this property being set as an integer. Really, though, we’d like to have this specified as a Bounds object so that user can specify distinct left, top, right, bottom paddings. With the 3.0 release we can make this only a bounds.

disableFirefoxOverflowHack

{Boolean} The hack for overflow in Firefox causes all elements to be re-drawn, which causes Flash elements to be re-initialized, which is troublesome. With this property the hack can be disabled.

fixPadding

fixPadding: function()

To be removed in 3.0, this function merely helps us to deal with the case where the user may have set an integer value for padding, instead of an OpenLayers.Bounds object.

map

{OpenLayers.Map} this gets set in Map.js when the popup is added to the map

OpenLayers. Popup

Create a popup.

Parameters

id	{String} a unqiue identifier for this popup. If null is passed an identifier will be automatically generated.
lonlat	{OpenLayers.LonLat} The position on the map the popup will be shown.
contentSize	{OpenLayers.Size} The size of the content.
contentHTML	{String} An HTML string to display inside the popup.
closeBox	{Boolean} Whether to display a close box inside the popup.
closeBoxCallback	{Function} Function to be called on closeBox click.

destroy

destroy: function()

nullify references to prevent circular references and memory leaks

draw

draw: function( px )

Constructs the elements that make up the popup.

Parameters

px	{OpenLayers.Pixel} the position the popup in pixels.

Returns

{DOMElement} Reference to a div that contains the drawn popup

updatePosition

updatePosition: function()

if the popup has a lonlat and its map members set, then have it move itself to its proper position

moveTo

moveTo: function( px )

Parameters

px	{OpenLayers.Pixel} the top and left position of the popup div.

visible

visible: function()

Returns

{Boolean} Boolean indicating whether or not the popup is visible

toggle

toggle: function()

Toggles visibility of the popup.

show

show: function()

Makes the popup visible.

hide

hide: function()

Makes the popup invisible.

setSize

setSize:function( contentSize )

Used to adjust the size of the popup.

Parameters

contentSize

{OpenLayers.Size} the new size for the popup’s contents div (in pixels).

setBackgroundColor

setBackgroundColor:function( color )

Sets the background color of the popup.

Parameters

color

{String} the background color. eg “#FFBBBB”

setOpacity

setOpacity:function( opacity )

Sets the opacity of the popup.

Parameters

opacity

{float} A value between 0.0 (transparent) and 1.0 (solid).

setBorder

setBorder:function( border )

Sets the border style of the popup.

Parameters

border

{String} The border style value. eg 2px

setContentHTML

setContentHTML:function( contentHTML )

Allows the user to set the HTML content of the popup.

Parameters

contentHTML

{String} HTML for the div.

registerImageListeners

registerImageListeners: function()

Called when an image contained by the popup loaded. this function updates the popup size, then unregisters the image load listener.

getContentDivPadding

getContentDivPadding: function()

Glorious, oh glorious hack in order to determine the css ‘padding’ of the contentDiv. IE/Opera return null here unless we actually add the popup’s main ‘div’ element (which contains contentDiv) to the DOM. So we make it invisible and then add it to the document temporarily.

Once we’ve taken the padding readings we need, we then remove it from the DOM (it will actually get added to the DOM in Map.js’s addPopup)

Returns

{OpenLayers.Protocol.Response}

addCloseBox

addCloseBox: function( callback )

Parameters

callback

{Function} The callback to be called when the close button is clicked.

panIntoView

panIntoView: function()

Pans the map such that the popup is totaly viewable (if necessary)

registerEvents

registerEvents:function()

Registers events on the popup.

Do this in a separate function so that subclasses can choose to override it if they wish to deal differently with mouse events

Note in the following handler functions that some special care is needed to deal correctly with mousing and popups.

Because the user might select the zoom-rectangle option and then drag it over a popup, we need a safe way to allow the mousemove and mouseup events to pass through the popup when they are initiated from outside.

Otherwise, we want to essentially kill the event propagation for all other events, though we have to do so carefully, without disabling basic html functionality, like clicking on hyperlinks or drag-selecting text.

onmousedown

onmousedown: function ( evt )

When mouse goes down within the popup, make a note of it locally, and then do not propagate the mousedown (but do so safely so that user can select text inside)

Parameters

evt

{Event}

onmousemove

onmousemove: function ( evt )

If the drag was started within the popup, then do not propagate the mousemove (but do so safely so that user can select text inside)

Parameters

evt

{Event}

onmouseup

onmouseup: function ( evt )

When mouse comes up within the popup, after going down in it, reset the flag, and then (once again) do not propagate the event, but do so safely so that user can select text inside

Parameters

evt

{Event}

onclick

onclick: function ( evt )

Ignore clicks, but allowing default browser handling

Parameters

evt

{Event}

onmouseout

onmouseout: function ( evt )

When mouse goes out of the popup set the flag to false so that if they let go and then drag back in, we won’t be confused.

Parameters

evt

{Event}

ondblclick

ondblclick: function ( evt )

Ignore double-clicks, but allowing default browser handling

Parameters

evt

{Event}

OpenLayers. Protocol

Abstract vector layer protocol class. Not to be instantiated directly. Use one of the protocol subclasses instead.

Summary

Properties
format	{OpenLayers.Format} The format used by this protocol.
options	{Object} Any options sent to the constructor.
autoDestroy	{Boolean} The creator of the protocol can set autoDestroy to false to fully control when the protocol is destroyed.
Functions
OpenLayers. Protocol	Abstract class for vector protocols.
abort	Abort an ongoing request.

Properties

format

{OpenLayers.Format} The format used by this protocol.

options

{Object} Any options sent to the constructor.

autoDestroy

{Boolean} The creator of the protocol can set autoDestroy to false to fully control when the protocol is destroyed. Defaults to true.

Functions

OpenLayers. Protocol

Abstract class for vector protocols. Create instances of a subclass.

Parameters

options

{Object} Optional object whose properties will be set on the instance.

abort

abort: function( response )

Abort an ongoing request.

Parameters

response

OpenLayers. Protocol. Response

Protocols return Response objects to their users.

Summary

Properties
code
requestType	{String} The type of request this response corresponds to.
last
features	{Array({OpenLayers.Feature.Vector})} or {OpenLayers.Feature.Vector} The features returned in the response by the server.
reqFeatures	{Array({OpenLayers.Feature.Vector})} or {OpenLayers.Feature.Vector} The features provided by the user and placed in the request by the protocol.
priv
Functions
OpenLayers. Protocol. Response
success

Properties

code

{Number}

OpenLayers.Protocol.Response.SUCCESS or OpenLayers.Protocol.Response.FAILURE

requestType

{String} The type of request this response corresponds to. Either “create”, “read”, “update” or “delete”.

last

{Boolean}

true if this is the last response expected in a commit, false otherwise, defaults to true.

features

{Array({OpenLayers.Feature.Vector})} or {OpenLayers.Feature.Vector} The features returned in the response by the server.

reqFeatures

{Array({OpenLayers.Feature.Vector})} or {OpenLayers.Feature.Vector} The features provided by the user and placed in the request by the protocol.

priv

Functions

OpenLayers. Protocol. Response

Parameters

options

{Object} Optional object whose properties will be set on the instance.

success

success: function()

Returns

{Boolean}

true on success, false otherwise

OpenLayers. Renderer

This is the base class for all renderers.

This is based on a merger code written by Paul Spencer and Bertil Chapuis. It is largely composed of virtual functions that are to be implemented in technology-specific subclasses, but there is some generic code too.

The functions that are implemented here merely deal with the maintenance of the size and extent variables, as well as the cached ‘resolution’ value.

A note to the user that all subclasses should use getResolution() instead of directly accessing this.resolution in order to correctly use the cacheing system.

Summary

Properties
container	{DOMElement}
root	{DOMElement}
extent	{OpenLayers.Bounds}
locked	{Boolean} If the renderer is currently in a state where many things are changing, the ‘locked’ property is set to true.
size	{OpenLayers.Size}
resolution	{Float} cache of current map resolution
map	{OpenLayers.Map} Reference to the map -- this is set in Vector’s setMap()
Functions
OpenLayers. Renderer
setExtent	Set the visible part of the layer.
setSize	Sets the size of the drawing surface.
getResolution	Uses cached copy of resolution if available to minimize computing
drawFeature	Draw the feature.
drawGeometry	Draw a geometry.
drawText	Function for drawing text labels.
removeText	Function for removing text labels.
clear	Clear all vectors from the renderer.
getFeatureIdFromEvent	Returns a feature id from an event on the renderer.
eraseFeatures	This is called by the layer to erase features
eraseGeometry	Remove a geometry from the renderer (by id).
moveRoot	moves this renderer’s root to a (different) renderer.
getRenderLayerId	Gets the layer that this renderer’s output appears on.

Properties

container

{DOMElement}

root

{DOMElement}

extent

locked

{Boolean} If the renderer is currently in a state where many things are changing, the ‘locked’ property is set to true. This means that renderers can expect at least one more drawFeature event to be called with the ‘locked’ property set to ‘true’: In some renderers, this might make sense to use as a ‘only update local information’ flag.

size

{OpenLayers.Size}

resolution

{Float} cache of current map resolution

map

{OpenLayers.Map} Reference to the map -- this is set in Vector’s setMap()

Functions

OpenLayers. Renderer

Parameters

containerID	{String}
options	{Object} options for this renderer. See sublcasses for supported options.

setExtent

setExtent: function( extent,
resolutionChanged )

Set the visible part of the layer.

Resolution has probably changed, so we nullify the resolution cache (this.resolution) -- this way it will be re-computed when next it is needed. We nullify the resolution cache (this.resolution) if resolutionChanged is set to true - this way it will be re-computed on the next getResolution() request.

Parameters

extent	{OpenLayers.Bounds}
resolutionChanged	{Boolean}

setSize

setSize: function( size )

Sets the size of the drawing surface.

Resolution has probably changed, so we nullify the resolution cache (this.resolution) -- this way it will be re-computed when next it is needed.

Parameters

size	{OpenLayers.Size}

getResolution

getResolution: function()

Uses cached copy of resolution if available to minimize computing

Returns

The current map’s resolution

drawFeature

drawFeature: function( feature,
style )

Draw the feature. The optional style argument can be used to override the feature’s own style. This method should only be called from layer.drawFeature().

Parameters

feature	{OpenLayers.Feature.Vector}
style	{<Object>}

Returns

{Boolean} true if the feature has been drawn completely, false if not, undefined if the feature had no geometry

drawGeometry

drawGeometry: function( geometry,
style,
featureId )

Draw a geometry. This should only be called from the renderer itself. Use layer.drawFeature() from outside the renderer. virtual function

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}
featureId	{String}

drawText

drawText: function( featureId,
style,
location )

Function for drawing text labels. This method is only called by the renderer itself.

Parameters

featureId	{String} style -
location	{OpenLayers.Geometry.Point}

removeText

removeText: function( featureId )

Function for removing text labels. This method is only called by the renderer itself.

Parameters

featureId

{String}

clear

clear: function()

Clear all vectors from the renderer. virtual function.

getFeatureIdFromEvent

getFeatureIdFromEvent: function( evt )

Returns a feature id from an event on the renderer. How this happens is specific to the renderer. This should be called from layer.getFeatureFromEvent(). Virtual function.

Parameters

evt	{OpenLayers.Event}

Returns

{String} A feature id or null.

eraseFeatures

eraseFeatures: function( features )

This is called by the layer to erase features

Parameters

features

eraseGeometry

eraseGeometry: function( geometry )

Remove a geometry from the renderer (by id). virtual function.

Parameters

geometry

{OpenLayers.Layer.Vector}

moveRoot

moveRoot: function( renderer )

moves this renderer’s root to a (different) renderer. To be implemented by subclasses that require a common renderer root for feature selection.

Parameters

renderer

{OpenLayers.Renderer} target renderer for the moved root

getRenderLayerId

getRenderLayerId: function()

Gets the layer that this renderer’s output appears on. If moveRoot was used, this will be different from the id of the layer containing the features rendered by this renderer.

Returns

{String} the id of the output layer.

OpenLayers. Strategy

Abstract vector layer strategy class. Not to be instantiated directly. Use one of the strategy subclasses instead.

Summary

Properties
layer	{OpenLayers.Layer.Vector} The layer this strategy belongs to.
options	{Object} Any options sent to the constructor.
active	{Boolean} The control is active.
autoActivate	{Boolean} The creator of the strategy can set autoActivate to false to fully control when the protocol is activated and deactivated.
autoDestroy	{Boolean} The creator of the strategy can set autoDestroy to false to fully control when the strategy is destroyed.
Functions
OpenLayers. Strategy	Abstract class for vector strategies.
setLayer	Called to set the layer property.
activate	Activate the strategy.
deactivate	Deactivate the strategy.

Properties

layer

{OpenLayers.Layer.Vector} The layer this strategy belongs to.

options

{Object} Any options sent to the constructor.

active

{Boolean} The control is active.

autoActivate

{Boolean} The creator of the strategy can set autoActivate to false to fully control when the protocol is activated and deactivated. Defaults to true.

autoDestroy

{Boolean} The creator of the strategy can set autoDestroy to false to fully control when the strategy is destroyed. Defaults to true.

Functions

OpenLayers. Strategy

Abstract class for vector strategies. Create instances of a subclass.

Parameters

options

{Object} Optional object whose properties will be set on the instance.

setLayer

setLayer: function( layer )

Called to set the layer property.

Parameters

activate

activate: function()

Activate the strategy. Register any listeners, do appropriate setup.

Returns

{Boolean} True if the strategy was successfully activated or false if the strategy was already active.

deactivate

deactivate: function()

Deactivate the strategy. Unregister any listeners, do appropriate tear-down.

Returns

{Boolean} True if the strategy was successfully deactivated or false if the strategy was already inactive.

OpenLayers. Control

Controls affect the display or behavior of the map. They allow everything from panning and zooming to displaying a scale indicator. Controls by default are added to the map they are contained within however it is possible to add a control to an external div by passing the div in the options parameter.

Example

The following example shows how to add many of the common controls to a map.

var map = new OpenLayers.Map('map', { controls: [] });

map.addControl(new OpenLayers.Control.PanZoomBar());
map.addControl(new OpenLayers.Control.MouseToolbar());
map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false}));
map.addControl(new OpenLayers.Control.Permalink());
map.addControl(new OpenLayers.Control.Permalink('permalink'));
map.addControl(new OpenLayers.Control.MousePosition());
map.addControl(new OpenLayers.Control.OverviewMap());
map.addControl(new OpenLayers.Control.KeyboardDefaults());

The next code fragment is a quick example of how to intercept shift-mouse click to display the extent of the bounding box dragged out by the user. Usually controls are not created in exactly this manner. See the source for a more complete example:

var control = new OpenLayers.Control();
OpenLayers.Util.extend(control, {
    draw: function () {
        // this Handler.Box will intercept the shift-mousedown
        // before Control.MouseDefault gets to see it
        this.box = new OpenLayers.Handler.Box( control,
            {"done": this.notice},
            {keyMask: OpenLayers.Handler.MOD_SHIFT});
        this.box.activate();
    },

    notice: function (bounds) {
        OpenLayers.Console.userError(bounds);
    }
});
map.addControl(control);

Summary

Properties
id	{String}
map	{OpenLayers.Map} this gets set in the addControl() function in OpenLayers.Map
div	{DOMElement}
type	{OpenLayers.Control.TYPES} Controls can have a ‘type’.
allowSelection	{Boolean} By deafault, controls do not allow selection, because it may interfere with map dragging.
displayClass	{string} This property is used for CSS related to the drawing of the Control.
title	{string} This property is used for showing a tooltip over the Control.
active	{Boolean} The control is active.
handler	{OpenLayers.Handler} null
events	{OpenLayers.Events} Events instance for triggering control specific events.
Constants
EVENT_TYPES	{Array(String)} Supported application event types.
Functions
OpenLayers. Control	Create an OpenLayers Control.
destroy	The destroy method is used to perform any clean up before the control is dereferenced.
setMap	Set the map property for the control.
draw	The draw method is called when the control is ready to be displayed on the page.
moveTo	Sets the left and top style attributes to the passed in pixel coordinates.
activate	Explicitly activates a control and it’s associated handler if one has been set.
deactivate	Deactivates a control and it’s associated handler if any.

Properties

id

{String}

map

{OpenLayers.Map} this gets set in the addControl() function in OpenLayers.Map

div

{DOMElement}

type

{OpenLayers.Control.TYPES} Controls can have a ‘type’. The type determines the type of interactions which are possible with them when they are placed into a toolbar.

allowSelection

{Boolean} By deafault, controls do not allow selection, because it may interfere with map dragging. If this is true, OpenLayers will not prevent selection of the control. Default is false.

displayClass

{string} This property is used for CSS related to the drawing of the Control.

title

{string} This property is used for showing a tooltip over the Control.

active

{Boolean} The control is active.

handler

{OpenLayers.Handler} null

events

{OpenLayers.Events} Events instance for triggering control specific events.

Constants

EVENT_TYPES

{Array(String)} Supported application event types. Register a listener for a particular event with the following syntax:

control.events.register(type, obj, listener);

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 control.events.object (a reference to the control).
element	{DOMElement} A reference to control.events.element (which will be null unless documented otherwise).

Supported map event types

activate	Triggered when activated.
deactivate	Triggered when deactivated.

Functions

OpenLayers. Control

Create an OpenLayers Control. The options passed as a parameter directly extend the control. For example passing the following:

var control = new OpenLayers.Control({div: myDiv});

Overrides the default div attribute value of null.

Parameters

options

{Object}

destroy

destroy: function ()

The destroy method is used to perform any clean up before the control is dereferenced. Typically this is where event listeners are removed to prevent memory leaks.

setMap

setMap: function( map )

Set the map property for the control. This is done through an accessor so that subclasses can override this and take special action once they have their map variable set.

Parameters

map	{OpenLayers.Map}

draw

draw: function ( px )

The draw method is called when the control is ready to be displayed on the page. If a div has not been created one is created. Controls with a visual component will almost always want to override this method to customize the look of control.

Parameters

px	{OpenLayers.Pixel} The top-left pixel position of the control or null.

Returns

{DOMElement} A reference to the DIV DOMElement containing the control

moveTo

moveTo: function ( px )

Sets the left and top style attributes to the passed in pixel coordinates.

Parameters

px	{OpenLayers.Pixel}

activate

activate: function ()

Explicitly activates a control and it’s associated handler if one has been set. Controls can be deactivated by calling the deactivate() method.

Returns

{Boolean} True if the control was successfully activated or false if the control was already active.

deactivate

deactivate: function ()

Deactivates a control and it’s associated handler if any. The exact effect of this depends on the control itself.

Returns

{Boolean} True if the control was effectively deactivated or false if the control was already inactive.

OpenLayers.Lang

Internationalization namespace. Contains dictionaries in various languages and methods to set and get the current language.

Summary

Properties
code	{String} Current language code to use in OpenLayers.

Properties

code

{String} Current language code to use in OpenLayers. Use the <setCode> method to set this value and the <getCode> method to retrieve it.

OpenLayers. Popup. Anchored

Inherits from

OpenLayers.Popup

Summary

Functions
OpenLayers. Popup. Anchored
moveTo	Since the popup is moving to a new px, it might need also to be moved relative to where the marker is.
calculateRelativePosition
updateRelativePosition	The popup has been moved to a new relative location, so we may want to make some cosmetic adjustments to it.
calculateNewPx

Functions

OpenLayers. Popup. Anchored

Parameters

id	{String}
lonlat	{OpenLayers.LonLat}
contentSize	{OpenLayers.Size}
contentHTML	{String}
anchor	{Object} Object which must expose a ‘size’ OpenLayers.Size and ‘offset’ OpenLayers.Pixel (generally an OpenLayers.Icon).
closeBox	{Boolean}
closeBoxCallback	{Function} Function to be called on closeBox click.

moveTo

moveTo: function( px )

Since the popup is moving to a new px, it might need also to be moved relative to where the marker is. We first calculate the new relativePosition, and then we calculate the new px where we will put the popup, based on the new relative position.

If the relativePosition has changed, we must also call updateRelativePosition() to make any visual changes to the popup which are associated with putting it in a new relativePosition.

Parameters

px	{OpenLayers.Pixel}

calculateRelativePosition

calculateRelativePosition:function( px )

Parameters

px	{OpenLayers.Pixel}

Returns

{String} The relative position (“br” “tr” “tl” “bl”) at which the popup should be placed.

updateRelativePosition

updateRelativePosition: function()

The popup has been moved to a new relative location, so we may want to make some cosmetic adjustments to it.

Note that in the classic Anchored popup, there is nothing to do here, since the popup looks exactly the same in all four positions. Subclasses such as the AnchoredBubble and Framed, however, will want to do something special here.

calculateNewPx

calculateNewPx:function( px )

Parameters

px	{OpenLayers.Pixel}

Returns

{OpenLayers.Pixel} The the new px position of the popup on the screen relative to the passed-in px.

OpenLayers. Renderer. Canvas

A renderer based on the 2D ‘canvas’ drawing element.element

Inherits

OpenLayers.Renderer

Summary

Properties
canvas	{Canvas} The canvas context object.
features	{Object} Internal object of feature/style pairs for use in redrawing the layer.
geometryMap	{Object} Geometry -> Feature lookup table.
Functions
OpenLayers. Renderer. Canvas
eraseGeometry	Erase a geometry from the renderer.
setExtent	Set the visible part of the layer.
setSize	Sets the size of the drawing surface.
drawFeature	Draw the feature.
drawGeometry	Used when looping (in redraw) over the features; draws the canvas.
drawExternalGraphic	Called to draw External graphics.
setCanvasStyle	Prepare the canvas for drawing by setting various global settings.
drawPoint	This method is only called by the renderer itself.
drawLineString	This method is only called by the renderer itself.
drawLinearRing	This method is only called by the renderer itself.
drawPolygon	This method is only called by the renderer itself.
drawText	This method is only called by the renderer itself.
getLocalXY	transform geographic xy into pixel xy
clear	Clear all vectors from the renderer.
getFeatureIdFromEvent	Returns a feature id from an event on the renderer.
eraseFeatures	This is called by the layer to erase features; removes the feature from the list, then redraws the layer.
redraw	The real ‘meat’ of the function: any time things have changed, redraw() can be called to loop over all the data and (you guessed it) redraw it.
Constants
OpenLayers. Renderer. Canvas. LABEL_ALIGN	{Object}

Properties

canvas

{Canvas} The canvas context object.

features

{Object} Internal object of feature/style pairs for use in redrawing the layer.

geometryMap

{Object} Geometry -> Feature lookup table. Used by eraseGeometry to lookup features to remove from our internal table (this.features) when erasing geoms.

Functions

OpenLayers. Renderer. Canvas

Parameters

containerID

{String}

eraseGeometry

eraseGeometry: function( geometry )

Erase a geometry from the renderer. Because the Canvas renderer has ‘memory’ of the features that it has drawn, we have to remove the feature so it doesn’t redraw.

Parameters

geometry

setExtent

setExtent: function( extent )

Set the visible part of the layer.

Resolution has probably changed, so we nullify the resolution cache (this.resolution), then redraw.

Parameters

extent

setSize

setSize: function( size )

Sets the size of the drawing surface.

Once the size is updated, redraw the canvas.

Parameters

size	{OpenLayers.Size}

drawFeature

drawFeature: function( feature,
style )

Draw the feature. Stores the feature in the features list, then redraws the layer.

Parameters

feature	{OpenLayers.Feature.Vector}
style	{<Object>}

drawGeometry

drawGeometry: function( geometry,
style )

Used when looping (in redraw) over the features; draws the canvas.

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}

drawExternalGraphic

drawExternalGraphic: function( pt,
style )

Called to draw External graphics.

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}

setCanvasStyle

setCanvasStyle: function( type,
style )

Prepare the canvas for drawing by setting various global settings.

Parameters

type	{String} one of ‘stroke’, ‘fill’, or ‘reset’
style	{Object} Symbolizer hash

drawPoint

drawPoint: function( geometry,
style )

This method is only called by the renderer itself.

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}

drawLineString

drawLineString: function( geometry,
style )

This method is only called by the renderer itself.

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}

drawLinearRing

drawLinearRing: function( geometry,
style )

This method is only called by the renderer itself.

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}

drawPolygon

drawPolygon: function( geometry,
style )

This method is only called by the renderer itself.

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}

drawText

drawText: function( location,
style )

This method is only called by the renderer itself.

Parameters

location	{<OpenLayers.Point>}
style	{Object}

getLocalXY

getLocalXY: function( point )

transform geographic xy into pixel xy

Parameters

point

clear

clear: function()

Clear all vectors from the renderer. virtual function.

getFeatureIdFromEvent

getFeatureIdFromEvent: function( evt )

Returns a feature id from an event on the renderer.

Parameters

evt	{OpenLayers.Event}

Returns

{String} A feature id or null.

eraseFeatures

eraseFeatures: function( features )

This is called by the layer to erase features; removes the feature from the list, then redraws the layer.

Parameters

features

redraw

redraw: function()

The real ‘meat’ of the function: any time things have changed, redraw() can be called to loop over all the data and (you guessed it) redraw it. Unlike Elements-based Renderers, we can’t interact with things once they’re drawn, to remove them, for example, so instead we have to just clear everything and draw from scratch.

Constants

OpenLayers. Renderer. Canvas. LABEL_ALIGN

{Object}

OpenLayers. ElementsIndexer

This class takes care of figuring out which order elements should be placed in the DOM based on given indexing methods.

Summary

Properties
maxZIndex	{Integer} This is the largest-most z-index value for a node contained within the indexer.
order	{Array<String>} This is an array of node id’s stored in the order that they should show up on screen.
indices	{Object} This is a hash that maps node ids to their z-index value stored in the indexer.
compare	{Function} This is the function used to determine placement of of a new node within the indexer.
Functions
determineZIndex	Determine the z-index for the current node if there isn’t one, and set the maximum value if we’ve found a new maximum.

Properties

maxZIndex

{Integer} This is the largest-most z-index value for a node contained within the indexer.

order

{Array<String>} This is an array of node id’s stored in the order that they should show up on screen. Id’s higher up in the array (higher array index) represent nodes with higher z-indeces.

indices

{Object} This is a hash that maps node ids to their z-index value stored in the indexer. This is done to make finding a nodes z-index value O(1).

compare

{Function} This is the function used to determine placement of of a new node within the indexer. If null, this defaults to to the Z_ORDER_DRAWING_ORDER comparison method.

Functions

determineZIndex

determineZIndex: function( node )

Determine the z-index for the current node if there isn’t one, and set the maximum value if we’ve found a new maximum.

Parameters

node	{DOMElement}

OpenLayers. ElementsIndexer. IndexingMethods

These are the compare methods for figuring out where a new node should be placed within the indexer. These methods are very similar to general sorting methods in that they return -1, 0, and 1 to specify the direction in which new nodes fall in the ordering.

Summary

Functions
Z_ORDER	This compare method is used by other comparison methods.

Functions

Z_ORDER

Z_ORDER: function( indexer,
newNode,
nextNode )

This compare method is used by other comparison methods. It can be used individually for ordering, but is not recommended, because it doesn’t subscribe to drawing order.

Parameters

indexer	{OpenLayers.ElementsIndexer}
newNode	{DOMElement}
nextNode	{DOMElement}

Returns

{Integer}

OpenLayers. Renderer. Elements

This is another virtual class in that it should never be instantiated by itself as a Renderer. It exists because there is tons of shared functionality between different vector libraries which use nodes/elements as a base for rendering vectors.

The highlevel bits of code that are implemented here are the adding and removing of geometries, which is essentially the same for any element-based renderer. The details of creating each node and drawing the paths are of course different, but the machinery is the same.

Inherits

OpenLayers.Renderer

Summary

Properties
rendererRoot	{DOMElement}
root	{DOMElement}
vectorRoot	{DOMElement}
textRoot	{DOMElement}
xmlns	{String}
Indexer	{<OpenLayers.ElementIndexer>} An instance of OpenLayers.ElementsIndexer created upon initialization if the zIndexing or yOrdering options passed to this renderer’s constructor are set to true.
Constants
BACKGROUND_ID_SUFFIX	{String}
BACKGROUND_ID_SUFFIX	{String}
Properties
minimumSymbolizer	{Object}
Functions
OpenLayers. Renderer. Elements
destroy
clear	Remove all the elements from the root
getNodeType	This function is in charge of asking the specific renderer which type of node to create for the given geometry and style.
drawGeometry	Draw the geometry, creating new nodes, setting paths, setting style, setting featureId on the node.
redrawNode
redrawBackgroundNode	Redraws the node using special ‘background’ style properties.
drawGeometryNode	Given a node, draw a geometry on the specified layer.
postDraw	Things that have do be done after the geometry node is appended to its parent node.
drawPoint	Virtual function for drawing Point Geometry.
drawLineString	Virtual function for drawing LineString Geometry.
drawLinearRing	Virtual function for drawing LinearRing Geometry.
drawPolygon	Virtual function for drawing Polygon Geometry.
drawRectangle	Virtual function for drawing Rectangle Geometry.
drawCircle	Virtual function for drawing Circle Geometry.
drawSurface	Virtual function for drawing Surface Geometry.
removeText	Removes a label
getFeatureIdFromEvent
eraseGeometry	Erase a geometry from the renderer.
nodeFactory	Create new node of the specified type, with the (optional) specified id.
nodeTypeCompare
createNode
moveRoot	moves this renderer’s root to a different renderer.
getRenderLayerId	Gets the layer that this renderer’s output appears on.
isComplexSymbol	Determines if a symbol cannot be rendered using drawCircle
Constants
OpenLayers. Renderer. symbol	Coordinate arrays for well known (named) symbols.

Properties

Constants

BACKGROUND_ID_SUFFIX

{String}

BACKGROUND_ID_SUFFIX

{String}

Properties

minimumSymbolizer

{Object}

Functions

OpenLayers. Renderer. Elements

Parameters

containerID	{String}
options	{Object} options for this renderer. Supported options are:

yOrdering - {Boolean} Whether to use y-ordering
zIndexing - {Boolean} Whether to use z-indexing. Will be ignored if yOrdering is set to true.

destroy

destroy: function()

clear

clear: function()

Remove all the elements from the root

getNodeType

getNodeType: function( geometry,
style )

This function is in charge of asking the specific renderer which type of node to create for the given geometry and style. All geometries in an Elements-based renderer consist of one node and some attributes. We have the nodeFactory() function which creates a node for us, but it takes a ‘type’ as input, and that is precisely what this function tells us.

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}

Returns

{String} The corresponding node type for the specified geometry

drawGeometry

drawGeometry: function( geometry,
style,
featureId )

Draw the geometry, creating new nodes, setting paths, setting style, setting featureId on the node. This method should only be called by the renderer itself.

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}
featureId	{String}

Returns

{Boolean} true if the geometry has been drawn completely; null if incomplete; false otherwise

redrawNode

redrawNode: function( id,
geometry,
style,
featureId )

Parameters

id	{String}
geometry	{OpenLayers.Geometry}
style	{Object}
featureId	{String}

Returns

{Boolean} true if the complete geometry could be drawn, null if parts of the geometry could not be drawn, false otherwise

redrawBackgroundNode

redrawBackgroundNode: function( id,
geometry,
style,
featureId )

Redraws the node using special ‘background’ style properties. Basically just calls redrawNode(), but instead of directly using the ‘externalGraphic’, ‘graphicXOffset’, ‘graphicYOffset’, and ‘graphicZIndex’ properties directly from the specified ‘style’ parameter, we create a new style object and set those properties from the corresponding ‘background’-prefixed properties from specified ‘style’ parameter.

Parameters

id	{String}
geometry	{OpenLayers.Geometry}
style	{Object}
featureId	{String}

Returns

{Boolean} true if the complete geometry could be drawn, null if parts of the geometry could not be drawn, false otherwise

drawGeometryNode

drawGeometryNode: function( node,
geometry,
style )

Given a node, draw a geometry on the specified layer. node and geometry are required arguments, style is optional. This method is only called by the render itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}
style	{Object}

Returns

{Object} a hash with properties “node” (the drawn node) and “complete” (null if parts of the geometry could not be drawn, false if nothing could be drawn)

postDraw

postDraw: function( node )

Things that have do be done after the geometry node is appended to its parent node. To be overridden by subclasses.

Parameters

node	{DOMElement}

drawPoint

drawPoint: function( node,
geometry )

Virtual function for drawing Point Geometry. Should be implemented by subclasses. This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or false if the renderer could not draw the point

drawLineString

drawLineString: function( node,
geometry )

Virtual function for drawing LineString Geometry. Should be implemented by subclasses. This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or null if the renderer could not draw all components of the linestring, or false if nothing could be drawn

drawLinearRing

drawLinearRing: function( node,
geometry )

Virtual function for drawing LinearRing Geometry. Should be implemented by subclasses. This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or null if the renderer could not draw all components of the linear ring, or false if nothing could be drawn

drawPolygon

drawPolygon: function( node,
geometry )

Virtual function for drawing Polygon Geometry. Should be implemented by subclasses. This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or null if the renderer could not draw all components of the polygon, or false if nothing could be drawn

drawRectangle

drawRectangle: function( node,
geometry )

Virtual function for drawing Rectangle Geometry. Should be implemented by subclasses. This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or false if the renderer could not draw the rectangle

drawCircle

drawCircle: function( node,
geometry )

Virtual function for drawing Circle Geometry. Should be implemented by subclasses. This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or false if the renderer could not draw the circle

drawSurface

drawSurface: function( node,
geometry )

Virtual function for drawing Surface Geometry. Should be implemented by subclasses. This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or false if the renderer could not draw the surface

removeText

removeText: function( featureId )

Removes a label

Parameters

featureId

{String}

getFeatureIdFromEvent

getFeatureIdFromEvent: function( evt )

Parameters

evt	{Object} An OpenLayers.Event object

Returns

{OpenLayers.Geometry} A geometry from an event that happened on a layer.

eraseGeometry

eraseGeometry: function( geometry )

Erase a geometry from the renderer. In the case of a multi-geometry, we cycle through and recurse on ourselves. Otherwise, we look for a node with the geometry.id, destroy its geometry, and remove it from the DOM.

Parameters

geometry

nodeFactory

nodeFactory: function( id,
type )

Create new node of the specified type, with the (optional) specified id.

If node already exists with same ID and a different type, we remove it and then call ourselves again to recreate it.

Parameters

id	{String}
type	{String} type Kind of node to draw.

Returns

{DOMElement} A new node of the given type and id.

nodeTypeCompare

nodeTypeCompare: function( node,
type )

Parameters

node	{DOMElement}
type	{String} Kind of node

Returns

{Boolean} Whether or not the specified node is of the specified type This function must be overridden by subclasses.

createNode

createNode: function( type,
id )

Parameters

type	{String} Kind of node to draw.
id	{String} Id for node.

Returns

{DOMElement} A new node of the given type and id. This function must be overridden by subclasses.

moveRoot

moveRoot: function( renderer )

moves this renderer’s root to a different renderer.

Parameters

renderer

{OpenLayers.Renderer} target renderer for the moved root

getRenderLayerId

getRenderLayerId: function()

Gets the layer that this renderer’s output appears on. If moveRoot was used, this will be different from the id of the layer containing the features rendered by this renderer.

Returns

{String} the id of the output layer.

isComplexSymbol

isComplexSymbol: function( graphicName )

Determines if a symbol cannot be rendered using drawCircle

Parameters

graphicName

{String}

Returns {Boolean} true if the symbol is complex, false if not

Constants

OpenLayers. Renderer. symbol

Coordinate arrays for well known (named) symbols.

OpenLayers. Strategy. Fixed

A simple strategy that requests features once and never requests new data.

Inherits from

OpenLayers.Strategy

Summary

Functions
OpenLayers. Strategy. Fixed	Create a new Fixed strategy.
activate	Activate the strategy: load data or add listener to load when visible
deactivate	Deactivate the strategy.
load	Tells protocol to load data and unhooks the visibilitychanged event
merge	Add all features to the layer.

Functions

OpenLayers. Strategy. Fixed

Create a new Fixed strategy.

Parameters

options

{Object} Optional object whose properties will be set on the instance.

activate

activate: function()

Activate the strategy: load data or add listener to load when visible

Returns

{Boolean} True if the strategy was successfully activated or false if the strategy was already active.

deactivate

deactivate: function()

Deactivate the strategy. Undo what is done in activate.

Returns

{Boolean} The strategy was successfully deactivated.

load

load: function( options )

Tells protocol to load data and unhooks the visibilitychanged event

Parameters

options

{Object} options to pass to protocol read.

merge

merge: function( resp )

Add all features to the layer.

OpenLayers. Tween

Summary

Constants
INTERVAL	{int} Interval in milliseconds between 2 steps
Properties
time	{int} Step counter
interval	{int} Interval id returned by window.setInterval
playing	{Boolean} Tells if the easing is currently playing
Functions
OpenLayers. Tween	Creates a Tween.
play	Calls the appropriate easing method

Constants

INTERVAL

{int} Interval in milliseconds between 2 steps

Properties

time

{int} Step counter

interval

{int} Interval id returned by window.setInterval

playing

{Boolean} Tells if the easing is currently playing

Functions

OpenLayers. Tween

Creates a Tween.

Parameters

easing

{<OpenLayers.Easing>(Function)} easing function method to use

play

play: function()

Calls the appropriate easing method

OpenLayers. Easing

Credits

Easing Equations by Robert Penner, http://www.robertpenner.com/easing/

OpenLayers. Easing. Linear

Summary

Functions
easeIn
easeOut
easeInOut

Functions

easeIn

easeIn: function( t,
b,
c,
d )

Parameters

t	{Float} time
b	{Float} beginning position
c	{Float} total change
d	{Float} duration of the transition

easeOut

easeOut: function( t,
b,
c,
d )

Parameters

t	{Float} time
b	{Float} beginning position
c	{Float} total change
d	{Float} duration of the transition

easeInOut

easeInOut: function( t,
b,
c,
d )

Parameters

t	{Float} time
b	{Float} beginning position
c	{Float} total change
d	{Float} duration of the transition

OpenLayers. Easing.Expo

Summary

Functions
easeIn
easeOut
easeInOut

Functions

easeIn

easeIn: function( t,
b,
c,
d )

Parameters

t	{Float} time
b	{Float} beginning position
c	{Float} total change
d	{Float} duration of the transition

easeOut

easeOut: function( t,
b,
c,
d )

Parameters

t	{Float} time
b	{Float} beginning position
c	{Float} total change
d	{Float} duration of the transition

easeInOut

easeInOut: function( t,
b,
c,
d )

Parameters

t	{Float} time
b	{Float} beginning position
c	{Float} total change
d	{Float} duration of the transition

OpenLayers. Easing.Quad

Summary

Functions
easeIn
easeOut
easeInOut

Functions

easeIn

easeIn: function( t,
b,
c,
d )

Parameters

t	{Float} time
b	{Float} beginning position
c	{Float} total change
d	{Float} duration of the transition

easeOut

easeOut: function( t,
b,
c,
d )

Parameters

t	{Float} time
b	{Float} beginning position
c	{Float} total change
d	{Float} duration of the transition

easeInOut

easeInOut: function( t,
b,
c,
d )

Parameters

t	{Float} time
b	{Float} beginning position
c	{Float} total change
d	{Float} duration of the transition

OpenLayers. Control. ArgParser

The ArgParser control adds location bar querystring parsing functionality to an OpenLayers Map. When added to a Map control, on a page load/refresh, the Map will automatically take the href string and parse it for lon, lat, zoom, and layers information.

Inherits from

OpenLayers.Control

Summary

Functions
OpenLayers. Control. ArgParser
setMap	Set the map property for the control.
setCenter	As soon as a baseLayer has been loaded, we center and zoom ...and remove the handler.
configureLayers	As soon as all the layers are loaded, cycle through them and hide or show them.

Functions

OpenLayers. Control. ArgParser

Parameters

options

{Object}

setMap

setMap: function( map )

Set the map property for the control.

Parameters

map	{OpenLayers.Map}

setCenter

setCenter: function()

As soon as a baseLayer has been loaded, we center and zoom ...and remove the handler.

configureLayers

configureLayers: function()

As soon as all the layers are loaded, cycle through them and hide or show them.

OpenLayers. Control. PanZoom

The PanZoom is a visible control, composed of a <OpenLayers.Control.PanPanel> and a <OpenLayers.Control.ZoomPanel>. By default it is drawn in the upper left corner of the map.

Inherits from

OpenLayers.Control

Summary

Properties
buttons	{Array(DOMElement)} Array of Button Divs
position	{OpenLayers.Pixel}
Functions
OpenLayers. Control. PanZoom
draw
_addButton
_removeButton
removeButtons
doubleClick
buttonDown
Constants
X	{Integer}
Y	{Integer}

Properties

buttons

{Array(DOMElement)} Array of Button Divs

position

Functions

OpenLayers. Control. PanZoom

Parameters

options

{Object}

draw

draw: function( px )

Parameters

px	{OpenLayers.Pixel}

Returns

{DOMElement} A reference to the container div for the PanZoom control.

_addButton

_addButton:function( id,
img,
xy,
sz )

Parameters

id	{String}
img	{String}
xy	{OpenLayers.Pixel}
sz	{OpenLayers.Size}

Returns

{DOMElement} A Div (an alphaImageDiv, to be precise) that contains the image of the button, and has all the proper event handlers set.

_removeButton

_removeButton: function( btn )

Parameters

btn

{Object}

removeButtons

removeButtons: function()

doubleClick

doubleClick: function ( evt )

Parameters

evt

{Event}

Returns

{Boolean}

buttonDown

buttonDown: function ( evt )

Parameters

evt

{Event}

Constants

X

{Integer}

Y

{Integer}

OpenLayers. Control. ScaleLine

The ScaleLine displays a small line indicator representing the current map scale on the map. By default it is drawn in the lower left corner of the map.

Inherits from

OpenLayers.Control

Is a very close copy of

<OpenLayers.Control.Scale>

Summary

Properties
maxWidth	{Integer} Maximum width of the scale line in pixels.
topOutUnits	{String} Units for zoomed out on top bar.
topInUnits	{String} Units for zoomed in on top bar.
bottomOutUnits	{String} Units for zoomed out on bottom bar.
bottomInUnits	{String} Units for zoomed in on bottom bar.
eTop	{DOMElement}
eBottom	{DOMElement}
Functions
OpenLayers. Control. ScaleLine	Create a new scale line control.
draw	{DOMElement}
getBarLen	Given a number, round it down to the nearest 1,2,5 times a power of 10.
update	Update the size of the bars, and the labels they contain.

Properties

maxWidth

{Integer} Maximum width of the scale line in pixels. Default is 100.

topOutUnits

{String} Units for zoomed out on top bar. Default is km.

topInUnits

{String} Units for zoomed in on top bar. Default is m.

bottomOutUnits

{String} Units for zoomed out on bottom bar. Default is mi.

bottomInUnits

getBarLen

getBarLen: function( maxLen )

Given a number, round it down to the nearest 1,2,5 times a power of 10. That seems a fairly useful set of number groups to use.

Parameters

maxLen

{float} the number we’re rounding down from

Returns

{Float} the rounded number (less than or equal to maxLen)

update

update: function()

Update the size of the bars, and the labels they contain.

OpenLayers. Event

Utility functions for event handling.

Summary

Properties
observers	{Object} A hashtable cache of the event observers.
Constants
KEY_BACKSPACE	{int}
KEY_TAB	{int}
KEY_RETURN	{int}
KEY_ESC	{int}
KEY_LEFT	{int}
KEY_UP	{int}
KEY_RIGHT	{int}
KEY_DOWN	{int}
KEY_DELETE	{int}
Functions
element	Cross browser event element detection.
isLeftClick	Determine whether event was caused by a left click.
isRightClick	Determine whether event was caused by a right mouse click.
stop	Stops an event from propagating.
findElement
observe
stopObservingElement	Given the id of an element to stop observing, cycle through the element’s cached observers, calling stopObserving on each one, skipping those entries which can no longer be removed.
_removeElementObservers
stopObserving
unloadCache	Cycle through all the element entries in the events cache and call stopObservingElement on each.

Properties

observers

{Object} A hashtable cache of the event observers. Keyed by element._eventCacheID

Constants

{Event}

Returns

{DOMElement} The element that caused the event

isLeftClick

isLeftClick: function( event )

Determine whether event was caused by a left click.

Parameters

event

{Event}

Returns

{Boolean}

isRightClick

isRightClick: function( event )

Determine whether event was caused by a right mouse click.

Parameters

event

{Event}

Returns

{Boolean}

stop

stop: function( event,
allowDefault )

Stops an event from propagating.

Parameters

event	{Event}
allowDefault	{Boolean} If true, we stop the event chain but still allow the default browser behaviour (text selection, radio-button clicking, etc) Default false

findElement

findElement: function( event,
tagName )

Parameters

event	{Event}
tagName	{String}

Returns

{DOMElement} The first node with the given tagName, starting from the node the event was triggered on and traversing the DOM upwards

observe

observe: function( elementParam,
name,
observer,
useCapture )

Parameters

elementParam	{DOMElement \|\| String}
name	{String}
observer	{function}
useCapture	{Boolean}

stopObservingElement

stopObservingElement: function( elementParam )

Given the id of an element to stop observing, cycle through the element’s cached observers, calling stopObserving on each one, skipping those entries which can no longer be removed.

parameters

elementParam

{DOMElement || String}

_removeElementObservers

_removeElementObservers: function( elementObservers )

Parameters

elementObservers

{Array(Object)} Array of (element, name, observer, usecapture) objects, taken directly from hashtable

stopObserving

stopObserving: function( elementParam,
name,
observer,
useCapture )

Parameters

elementParam	{DOMElement \|\| String}
name	{String}
observer	{function}
useCapture	{Boolean}

Returns

{Boolean} Whether or not the event observer was removed

unloadCache

unloadCache: function()

Cycle through all the element entries in the events cache and call stopObservingElement on each.

OpenLayers. Events

Summary

Constants
BROWSER_EVENTS	{Array(String)} supported events
Properties
listeners	{Object} Hashtable of Array(Function): events listener functions
object	{Object} the code object issuing application events
element	{DOMElement} the DOM element receiving browser events
eventTypes	{Array(String)} list of support application events
eventHandler	{Function} bound event handler attached to elements
Functions
clearMouseListener	A version of <clearMouseCache> that is bound to this instance so that it can be used with OpenLayers.Event.observe and OpenLayers.Event.stopObserving.
OpenLayers. Events	Construct an OpenLayers.Events object.
attachToElement
on	Convenience method for registering listeners with a common scope.
un	Convenience method for unregistering listeners with a common scope.
remove	Remove all listeners for a given event type.
handleBrowserEvent	Basically just a wrapper to the triggerEvent() function, but takes care to set a property ‘xy’ on the event with the current mouse position.
getMousePosition

Constants

BROWSER_EVENTS

{Array(String)} supported events

Properties

listeners

{Object} Hashtable of Array(Function): events listener functions

object

{Object} the code object issuing application events

element

{DOMElement} the DOM element receiving browser events

eventTypes

{Array(String)} list of support application events

eventHandler

{Function} bound event handler attached to elements

Functions

clearMouseListener

A version of <clearMouseCache> that is bound to this instance so that it can be used with OpenLayers.Event.observe and OpenLayers.Event.stopObserving.

OpenLayers. Events

Construct an OpenLayers.Events object.

Parameters

object	{Object} The js object to which this Events object is being
added element	{DOMElement} A dom element to respond to browser events
eventTypes	{Array(String)} Array of custom application events
fallThrough	{Boolean} Allow events to fall through after these have been handled?
options	{Object} Options for the events object.

attachToElement

attachToElement: function ( element )

Parameters

element

{HTMLDOMElement} a DOM element to attach browser events to

on

on: function( object )

Convenience method for registering listeners with a common scope.

Example use

events.on({
    "loadstart": loadStartListener,
    "loadend": loadEndListener,
    scope: object
});

un

un: function( object )

Convenience method for unregistering listeners with a common scope.

Example use

events.un({
    "loadstart": loadStartListener,
    "loadend": loadEndListener,
    scope: object
});

remove

remove: function( type )

Remove all listeners for a given event type. If type is not registered, does nothing.

Parameters

type

{String}

handleBrowserEvent

handleBrowserEvent: function ( evt )

Basically just a wrapper to the triggerEvent() function, but takes care to set a property ‘xy’ on the event with the current mouse position.

Parameters

evt

{Event}

getMousePosition

getMousePosition: function ( evt )

Parameters

evt

{Event}

Returns

{OpenLayers.Pixel} The current xy coordinate of the mouse, adjusted for offsets

OpenLayers. Format

Base class for format reading/writing a variety of formats. Subclasses of OpenLayers.Format are expected to have read and write methods.

Summary

Properties
options	{Object} A reference to options passed to the constructor.
Functions
OpenLayers. Format	Instances of this class are not useful.
read	Read data from a string, and return an object whose type depends on the subclass.
write	Accept an object, and return a string.

Properties

options

{Object} A reference to options passed to the constructor.

Functions

OpenLayers. Format

Instances of this class are not useful. See one of the subclasses.

Parameters

options

{Object} An optional object with properties to set on the format

Valid options

keepData

{Boolean} If true, upon read, the data property will be set to the parsed object (e.g. the json or xml object).

Returns

An instance of OpenLayers.Format

read

read: function( data )

Read data from a string, and return an object whose type depends on the subclass.

Parameters

data	{string} Data to read/parse.

Returns

Depends on the subclass

write

write: function( object )

Accept an object, and return a string.

Parameters

object

{Object} Object to be serialized

Returns

{String} A string representation of the object.

OpenLayers. Lang[“en”]

Dictionary for English. Keys for entries are used in calls to <OpenLayers.Lang.translate>. Entry bodies are normal strings or strings formatted for use with <OpenLayers.String.format> calls.

OpenLayers. Popup. AnchoredBubble

Inherits from

OpenLayers.Popup.Anchored

Summary

Properties
rounded	{Boolean} Has the popup been rounded yet?
Functions
OpenLayers. Popup. AnchoredBubble
draw
updateRelativePosition	The popup has been moved to a new relative location, in which case we will want to re-do the rico corners.
setBorder	Always sets border to 0.
setRicoCorners	Update RICO corners according to the popup’s current relative postion.
getCornersToRound	{String} The proper corners string (“tr tl bl br”) for rico to round.
Constants
CORNER_SIZE	{Integer} 5.

Properties

rounded

{Boolean} Has the popup been rounded yet?

Functions

OpenLayers. Popup. AnchoredBubble

Parameters

id	{String}
lonlat	{OpenLayers.LonLat}
contentSize	{OpenLayers.Size}
contentHTML	{String}
anchor	{Object} Object to which we’ll anchor the popup. Must expose a ‘size’ (OpenLayers.Size) and ‘offset’ (OpenLayers.Pixel) (Note that this is generally an OpenLayers.Icon).
closeBox	{Boolean}
closeBoxCallback	{Function} Function to be called on closeBox click.

draw

draw: function( px )

Parameters

px	{OpenLayers.Pixel}

Returns

{DOMElement} Reference to a div that contains the drawn popup.

updateRelativePosition

updateRelativePosition: function()

The popup has been moved to a new relative location, in which case we will want to re-do the rico corners.

setBorder

setBorder:function( border )

Always sets border to 0. Bubble Popups can not have a border.

Parameters

border

{Integer}

setRicoCorners

setRicoCorners:function()

Update RICO corners according to the popup’s current relative postion.

getCornersToRound

getCornersToRound:function()

Returns

{String} The proper corners string (“tr tl bl br”) for rico to round.

Constants

CORNER_SIZE

{Integer} 5. Border space for the RICO corners.

OpenLayers. Projection

Class for coordinate transforms between coordinate systems. Depends on the proj4js library. If proj4js is not available, then this is just an empty stub.

Summary

Properties
proj	{Object} Proj4js.Proj instance.
projCode	{String}
Functions
OpenLayers. Projection	This class offers several methods for interacting with a wrapped pro4js projection object.
toString	Convert projection to string (getCode wrapper).
equals	Test equality of two projection instances.
destroy	Destroy projection object.
Properties
transforms	Transforms is an object, with from properties, each of which may have a to property.

Properties

proj

{Object} Proj4js.Proj instance.

projCode

{String}

Functions

OpenLayers. Projection

This class offers several methods for interacting with a wrapped pro4js projection object.

Parameters

projCode	{String} A string identifying the Well Known Identifier for the projection.
options	{Object} An optional object to set additional properties on the layer.

Returns

{OpenLayers.Projection} A projection object.

toString

toString: function()

Convert projection to string (getCode wrapper).

Returns

{String} The projection code.

equals

equals: function( projection )

Test equality of two projection instances. Determines equality based soley on the projection code.

Returns

{Boolean} The two projections are equivalent.

destroy

destroy: function()

Destroy projection object.

Properties

transforms

Transforms is an object, with from properties, each of which may have a to property. This allows you to define projections without requiring support for proj4js to be included.

This object has keys which correspond to a ‘source’ projection object. The keys should be strings, corresponding to the projection.getCode() value. Each source projection object should have a set of destination projection keys included in the object.

Each value in the destination object should be a transformation function, where the function is expected to be passed an object with a .x and a .y property. The function should return the object, with the .x and .y transformed according to the transformation function.

Note	Properties on this object should not be set directly. To add a transform method to this object, use the <addTransform> method. For an example of usage, see the OpenLayers.Layer.SphericalMercator file.

OpenLayers. Renderer.SVG

Inherits

OpenLayers.Renderer.Elements

Summary

Properties
xmlns	{String}
xlinkns	{String}
Constants
MAX_PIXEL	{Integer} Firefox has a limitation where values larger or smaller than about 15000 in an SVG document lock the browser up.
Properties
translationParameters	{Object} Hash with “x” and “y” properties
symbolSize	{Object} Cache for symbol sizes according to their svg coordinate space
isGecko	{Boolean}
Functions
OpenLayers. Renderer.SVG
inValidRange	See #669 for more information
setExtent
translate	Transforms the SVG coordinate system
setSize	Sets the size of the drawing surface.
getNodeType
setStyle	Use to set all the style attributes to a SVG node.
dashStyle
createNode
nodeTypeCompare
createRenderRoot	{DOMElement} The specific render engine’s root element
createRoot
createDefs	{DOMElement} The element to which we’ll add the symbol definitions
drawPoint	This method is only called by the renderer itself.
drawCircle	This method is only called by the renderer itself.
drawLineString	This method is only called by the renderer itself.
drawLinearRing	This method is only called by the renderer itself.
drawPolygon	This method is only called by the renderer itself.
drawRectangle	This method is only called by the renderer itself.
drawSurface	This method is only called by the renderer itself.
drawText	This method is only called by the renderer itself.
getComponentString
clipLine	Given two points (one inside the valid range, and one outside), clips the line betweeen the two points so that the new points are both inside the valid range.
getShortString
getPosition	Finds the position of an svg node.
importSymbol	add a new symbol definition from the rendererer’s symbol hash
Constants
OpenLayers. Renderer. SVG. LABEL_ALIGN	{Object}
OpenLayers. Renderer. SVG. LABEL_VSHIFT	{Object}

Properties

xmlns

{String}

xlinkns

{String}

Constants

MAX_PIXEL

{Integer} Firefox has a limitation where values larger or smaller than about 15000 in an SVG document lock the browser up. This works around it.

Properties

translationParameters

{Object} Hash with “x” and “y” properties

symbolSize

{Object} Cache for symbol sizes according to their svg coordinate space

isGecko

{Boolean}

Functions

OpenLayers. Renderer.SVG

Parameters

containerID

{String}

inValidRange

inValidRange: function( x,
y,
xyOnly )

See #669 for more information

Parameters

x	{Integer}
y	{Integer}
xyOnly	{Boolean} whether or not to just check for x and y, which means to not take the current translation parameters into account if true.

Returns

{Boolean} Whether or not the ‘x’ and ‘y’ coordinates are in the valid range.

setExtent

setExtent: function( extent,
resolutionChanged )

Parameters

extent	{OpenLayers.Bounds}
resolutionChanged	{Boolean}

Returns

{Boolean} true to notify the layer that the new extent does not exceed the coordinate range, and the features will not need to be redrawn. False otherwise.

translate

translate: function( x,
y )

Transforms the SVG coordinate system

Parameters

x	{Float}
y	{Float}

Returns

{Boolean} true if the translation parameters are in the valid coordinates range, false otherwise.

setSize

setSize: function( size )

Sets the size of the drawing surface.

Parameters

size	{OpenLayers.Size} The size of the drawing surface

getNodeType

getNodeType: function( geometry,
style )

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}

Returns

{String} The corresponding node type for the specified geometry

setStyle

setStyle: function( node,
style,
options )

Use to set all the style attributes to a SVG node.

Takes care to adjust stroke width and point radius to be resolution-relative

Parameters

node	{SVGDomElement} An SVG element to decorate
style	{Object}
options	{Object} Currently supported options include ‘isFilled’ {Boolean} and ‘isStroked’ {Boolean}

dashStyle

dashStyle: function( style,
widthFactor )

Parameters

style	{Object}
widthFactor	{Number}

Returns

{String} A SVG compliant ‘stroke-dasharray’ value

createNode

createNode: function( type,
id )

Parameters

type	{String} Kind of node to draw
id	{String} Id for node

Returns

{DOMElement} A new node of the given type and id

nodeTypeCompare

nodeTypeCompare: function( node,
type )

Parameters

node	{SVGDomElement} An SVG element
type	{String} Kind of node

Returns

{Boolean} Whether or not the specified node is of the specified type

createRenderRoot

createRenderRoot: function()

Returns

{DOMElement} The specific render engine’s root element

createRoot

createRoot: function( suffix )

Parameter

suffix

{String} suffix to append to the id

Returns

{DOMElement}

createDefs

createDefs: function()

Returns

{DOMElement} The element to which we’ll add the symbol definitions

drawPoint

drawPoint: function( node,
geometry )

This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or false if the renderer could not draw the point

drawCircle

drawCircle: function( node,
geometry,
radius )

This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}
radius	{Float}

Returns

{DOMElement} or false if the renderer could not draw the circle

drawLineString

drawLineString: function( node,
geometry )

This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or null if the renderer could not draw all components of the linestring, or false if nothing could be drawn

drawLinearRing

drawLinearRing: function( node,
geometry )

This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or null if the renderer could not draw all components of the linear ring, or false if nothing could be drawn

drawPolygon

drawPolygon: function( node,
geometry )

This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or null if the renderer could not draw all components of the polygon, or false if nothing could be drawn

drawRectangle

drawRectangle: function( node,
geometry )

This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or false if the renderer could not draw the rectangle

drawSurface

drawSurface: function( node,
geometry )

This method is only called by the renderer itself.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or false if the renderer could not draw the surface

drawText

drawText: function( featureId,
style,
location )

This method is only called by the renderer itself.

Parameters

featureId	{String} style -
location	{OpenLayers.Geometry.Point}

getComponentString

Parameters

components	{Array(OpenLayers.Geometry.Point)} Array of points
separator	{String} character between coordinate pairs. Defaults to “,”

Returns

{Object} hash with properties “path” (the string created from the components and “complete” (false if the renderer was unable to draw all components)

clipLine

clipLine: function( badComponent,
goodComponent )

Given two points (one inside the valid range, and one outside), clips the line betweeen the two points so that the new points are both inside the valid range.

Parameters

badComponent	{OpenLayers.Geometry.Point)} original geometry of the invalid point
goodComponent	{OpenLayers.Geometry.Point)} original geometry of the valid point Returns {String} the SVG coordinate pair of the clipped point (like getShortString), or an empty string if both passed componets are at the same point.

getShortString

getShortString: function( point )

Parameters

point

Returns

{String} or false if point is outside the valid range

getPosition

getPosition: function( node )

Finds the position of an svg node.

Parameters

node	{DOMElement}

Returns

{Object} hash with x and y properties, representing the coordinates within the svg coordinate system

importSymbol

importSymbol: function ( graphicName )

add a new symbol definition from the rendererer’s symbol hash

Parameters

graphicName

{String} name of the symbol to import

Returns

{String}

id of the imported symbol

Constants

OpenLayers. Renderer. SVG. LABEL_ALIGN

{Object}

OpenLayers. Renderer. SVG. LABEL_VSHIFT

{Object}

OpenLayers. Renderer.VML

Render vector features in browsers with VML capability. Construct a new VML renderer with the OpenLayers.Renderer.VML constructor.

Note that for all calculations in this class, we use toFixed() to round a float value to an integer. This is done because it seems that VML doesn’t support float values.

Inherits from

OpenLayers.Renderer.Elements

Summary

Properties
xmlns	{String} XML Namespace URN
symbolCache	{DOMElement} node holding symbols.
offset	{Object} Hash with “x” and “y” properties
Functions
OpenLayers. Renderer.VML	Create a new VML renderer.
setExtent	Set the renderer’s extent
setSize	Set the size of the drawing surface
getNodeType	Get the node type for a geometry and style
setStyle	Use to set all the style attributes to a VML node.
graphicRotate	If a point is to be styled with externalGraphic and rotation, VML fills cannot be used to display the graphic, because rotation of graphic fills is not supported by the VML implementation of Internet Explorer.
postDraw	Some versions of Internet Explorer seem to be unable to set fillcolor and strokecolor to “none” correctly before the fill node is appended to a visible vml node.
setNodeDimension	Get the geometry’s bounds, convert it to our vml coordinate system, then set the node’s position, size, and local coordinate system.
dashStyle
createNode	Create a new node
nodeTypeCompare	Determine whether a node is of a given type
createRenderRoot	Create the renderer root
createRoot	Create the main root element
drawPoint	Render a point
drawCircle	Render a circle.
drawLineString	Render a linestring.
drawLinearRing	Render a linearring
DrawLine	Render a line.
drawPolygon	Render a polygon
drawRectangle	Render a rectangle
drawText	This method is only called by the renderer itself.
drawSurface
moveRoot	moves this renderer’s root to a different renderer.
importSymbol	add a new symbol definition from the rendererer’s symbol hash
Constants
OpenLayers. Renderer. VML. LABEL_SHIFT	{Object}

Properties

xmlns

{String} XML Namespace URN

symbolCache

{DOMElement} node holding symbols. This hash is keyed by symbol name, and each value is a hash with a “path” and an “extent” property.

offset

{Object} Hash with “x” and “y” properties

Functions

OpenLayers. Renderer.VML

Create a new VML renderer.

Parameters

containerID

{String} The id for the element that contains the renderer

setExtent

setExtent: function( extent,
resolutionChanged )

Set the renderer’s extent

Parameters

extent	{OpenLayers.Bounds}
resolutionChanged	{Boolean}

Returns

{Boolean} true to notify the layer that the new extent does not exceed the coordinate range, and the features will not need to be redrawn.

setSize

setSize: function( size )

Set the size of the drawing surface

Parameters

size	{OpenLayers.Size} the size of the drawing surface

getNodeType

getNodeType: function( geometry,
style )

Get the node type for a geometry and style

Parameters

geometry	{OpenLayers.Geometry}
style	{Object}

Returns

{String} The corresponding node type for the specified geometry

setStyle

setStyle: function( node,
style,
options,
geometry )

Use to set all the style attributes to a VML node.

Parameters

node	{DOMElement} An VML element to decorate
style	{Object}
options	{Object} Currently supported options include ‘isFilled’ {Boolean} and ‘isStroked’ {Boolean}
geometry	{OpenLayers.Geometry}

graphicRotate

graphicRotate: function( node,
xOffset,
yOffset )

If a point is to be styled with externalGraphic and rotation, VML fills cannot be used to display the graphic, because rotation of graphic fills is not supported by the VML implementation of Internet Explorer. This method creates a olv:imagedata element inside the VML node, DXImageTransform.Matrix and BasicImage filters for rotation and opacity, and a 3-step hack to remove rendering artefacts from the graphic and preserve the ability of graphics to trigger events. Finally, OpenLayers methods are used to determine the correct insertion point of the rotated image, because DXImageTransform.Matrix does the rotation without the ability to specify a rotation center point.

Parameters

node	{DOMElement}
xOffset	{Number} rotation center relative to image, x coordinate
yOffset	{Number} rotation center relative to image, y coordinate

postDraw

postDraw: function( node )

Some versions of Internet Explorer seem to be unable to set fillcolor and strokecolor to “none” correctly before the fill node is appended to a visible vml node. This method takes care of that and sets fillcolor and strokecolor again if needed.

Parameters

node	{DOMElement}

setNodeDimension

setNodeDimension: function( node,
geometry )

Get the geometry’s bounds, convert it to our vml coordinate system, then set the node’s position, size, and local coordinate system.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

dashStyle

dashStyle: function( style )

Parameters

style

{Object}

Returns

{String} A VML compliant ‘stroke-dasharray’ value

createNode

createNode: function( type,
id )

Create a new node

Parameters

type	{String} Kind of node to draw
id	{String} Id for node

Returns

{DOMElement} A new node of the given type and id

nodeTypeCompare

nodeTypeCompare: function( node,
type )

Determine whether a node is of a given type

Parameters

node	{DOMElement} An VML element
type	{String} Kind of node

Returns

{Boolean} Whether or not the specified node is of the specified type

createRenderRoot

createRenderRoot: function()

Create the renderer root

Returns

{DOMElement} The specific render engine’s root element

createRoot

createRoot: function( suffix )

Create the main root element

Parameters

suffix

{String} suffix to append to the id

Returns

{DOMElement}

drawPoint

drawPoint: function( node,
geometry )

Render a point

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement} or false if the point could not be drawn

drawCircle

drawCircle: function( node,
geometry,
radius )

Render a circle. Size and Center a circle given geometry (x,y center) and radius

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}
radius	{float}

Returns

{DOMElement} or false if the circle could not ne drawn

drawLineString

drawLineString: function( node,
geometry )

Render a linestring.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement}

drawLinearRing

drawLinearRing: function( node,
geometry )

Render a linearring

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement}

DrawLine

Render a line.

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}
closeLine	{Boolean} Close the line? (make it a ring?)

Returns

{DOMElement}

drawPolygon

drawPolygon: function( node,
geometry )

Render a polygon

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement}

drawRectangle

drawRectangle: function( node,
geometry )

Render a rectangle

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement}

drawText

drawText: function( featureId,
style,
location )

This method is only called by the renderer itself.

Parameters

featureId	{String} style -
location	{OpenLayers.Geometry.Point}

drawSurface

drawSurface: function( node,
geometry )

Parameters

node	{DOMElement}
geometry	{OpenLayers.Geometry}

Returns

{DOMElement}

moveRoot

moveRoot: function( renderer )

moves this renderer’s root to a different renderer.

Parameters

renderer	{OpenLayers.Renderer} target renderer for the moved root
root	{DOMElement} optional root node. To be used when this renderer holds roots from multiple layers to tell this method which one to detach

Returns

{Boolean} true if successful, false otherwise

importSymbol

importSymbol: function ( graphicName )

add a new symbol definition from the rendererer’s symbol hash

Parameters

graphicName

{String} name of the symbol to import

Returns

{Object}

hash of {DOMElement} “symbol” and {Number} “size”

Constants

OpenLayers. Renderer. VML. LABEL_SHIFT

{Object}

OpenLayers.Tile

This is a class designed to designate a single tile, however it is explicitly designed to do relatively little. Tiles store information about themselves -- such as the URL that they are related to, and their size - but do not add themselves to the layer div automatically, for example. Create a new tile with the OpenLayers.Tile constructor, or a subclass.

TBD 3.0

remove reference to url in above paragraph

Summary

Constants
EVENT_TYPES	{Array(String)} Supported application event types
Properties
id	{String} null
layer	{OpenLayers.Layer} layer the tile is attached to
url	{String} url of the request.
size	{OpenLayers.Size} null
position	{OpenLayers.Pixel} Top Left pixel of the tile
isLoading	{Boolean} Is the tile loading?
Functions
OpenLayers.Tile	Constructor for a new OpenLayers.Tile instance.
unload	Call immediately before destroying if you are listening to tile events, so that counters are properly handled if tile is still loading at destroy-time.
clone
draw	Clear whatever is currently in the tile, then return whether or not it should actually be re-drawn.
moveTo	Reposition the tile.
clear	Clear the tile of any bounds/position-related data so that it can be reused in a new location.
getBoundsFromBaseLayer	Take the pixel locations of the corner of the tile, and pass them to the base layer and ask for the location of those pixels, so that displaying tiles over Google works fine.
showTile	Show the tile only if it should be drawn.
show	Show the tile.
hide	Hide the tile.

Constants

EVENT_TYPES

{Array(String)} Supported application event types

Properties

id

{String} null

layer

{OpenLayers.Layer} layer the tile is attached to

url

{String} url of the request.

TBD 3.0 Deprecated. The base tile class does not need an url. This should be handled in subclasses. Does not belong here.

size

{OpenLayers.Size} null

position

{OpenLayers.Pixel} Top Left pixel of the tile

isLoading

{Boolean} Is the tile loading?

Functions

OpenLayers.Tile

Constructor for a new OpenLayers.Tile instance.

Parameters

layer	{OpenLayers.Layer} layer that the tile will go in.
position	{OpenLayers.Pixel}
bounds	{OpenLayers.Bounds}
url	{String}
size	{OpenLayers.Size}

unload

unload: function()

Call immediately before destroying if you are listening to tile events, so that counters are properly handled if tile is still loading at destroy-time. Will only fire an event if the tile is still loading.

clone

clone: function ( obj )

Parameters

obj	{OpenLayers.Tile} The tile to be cloned

Returns

{OpenLayers.Tile} An exact clone of this OpenLayers.Tile

draw

draw: function()

Clear whatever is currently in the tile, then return whether or not it should actually be re-drawn.

Returns

{Boolean} Whether or not the tile should actually be drawn. Note that this is not really the best way of doing things, but such is the way the code has been developed. Subclasses call this and depend on the return to know if they should draw or not.

moveTo

moveTo: function ( bounds,
position,
redraw )

Reposition the tile.

Parameters

bounds	{OpenLayers.Bounds}
position	{OpenLayers.Pixel}
redraw	{Boolean} Call draw method on tile after moving. Default is true

clear

clear: function()

Clear the tile of any bounds/position-related data so that it can be reused in a new location. To be implemented by subclasses.

getBoundsFromBaseLayer

getBoundsFromBaseLayer: function( position )

Take the pixel locations of the corner of the tile, and pass them to the base layer and ask for the location of those pixels, so that displaying tiles over Google works fine.

Parameters

position

Returns

bounds

showTile

showTile: function()

Show the tile only if it should be drawn.

show

show: function()

Show the tile. To be implemented by subclasses.

hide

hide: function()

Hide the tile. To be implemented by subclasses.

OpenLayers. Format.XML

Read and write XML. For cross-browser XML generation, use methods on an instance of the XML format class instead of on <code>document<end>. The DOM creation and traversing methods exposed here all mimic the W3C XML DOM methods. Create a new parser with the OpenLayers.Format.XML constructor.

Inherits from

OpenLayers.Format

Summary

Properties
namespaces	{Object} Mapping of namespace aliases to namespace URIs.
namespaceAlias	{Object} Mapping of namespace URI to namespace alias.
defaultPrefix	{String} The default namespace alias for creating element nodes.
readers	Contains public functions, grouped by namespace prefix, that will be applied when a namespaced node is found matching the function name.
writers	As a compliment to the readers property, this structure contains public writing functions grouped by namespace alias and named like the node names they produce.
xmldom	{XMLDom} If this browser uses ActiveX, this will be set to a XMLDOM object.
Functions
OpenLayers. Format.XML	Construct an XML parser.
setNamespace	Set a namespace alias and URI for the format.
createElementNSPlus	Shorthand for creating namespaced elements with optional attributes and child text nodes.
setAttributes	Set multiple attributes given key value pairs from an object.
readNode	Shorthand for applying one of the named readers given the node namespace and local name.
readChildNodes	Shorthand for applying the named readers to all children of a node.
writeNode	Shorthand for applying one of the named writers and appending the results to a node.
getThisOrNextEl	Return this node or the next element node.

Properties

namespaces

{Object} Mapping of namespace aliases to namespace URIs. Properties of this object should not be set individually. Read-only. All XML subclasses should have their own namespaces object. Use setNamespace to add or set a namespace alias after construction.

namespaceAlias

{Object} Mapping of namespace URI to namespace alias. This object is read-only. Use setNamespace to add or set a namespace alias.

defaultPrefix

{String} The default namespace alias for creating element nodes.

readers

Contains public functions, grouped by namespace prefix, that will be applied when a namespaced node is found matching the function name. The function will be applied in the scope of this parser with two arguments: the node being read and a context object passed from the parent.

writers

As a compliment to the readers property, this structure contains public writing functions grouped by namespace alias and named like the node names they produce.

xmldom

{XMLDom} If this browser uses ActiveX, this will be set to a XMLDOM object. It is not intended to be a browser sniffing property. Instead, the xmldom property is used instead of <code>document<end> where namespaced node creation methods are not supported. In all other browsers, this remains null.

Functions

OpenLayers. Format.XML

Construct an XML parser. The parser is used to read and write XML. Reading XML from a string returns a DOM element. Writing XML from a DOM element returns a string.

Parameters

options

{Object} Optional object whose properties will be set on the object.

setNamespace

setNamespace: function( alias,
uri )

Set a namespace alias and URI for the format.

Parameters

alias	{String} The namespace alias (prefix).
uri	{String} The namespace URI.

createElementNSPlus

createElementNSPlus: function( name,
options )

Shorthand for creating namespaced elements with optional attributes and child text nodes.

Parameters

name	{String} The qualified node name.
options	{Object} Optional object for node configuration.

Valid options

uri	{String} Optional namespace uri for the element - supply a prefix instead if the namespace uri is a property of the format’s namespace object.
attributes	{Object} Optional attributes to be set using the setAttributes method.
value	{String} Optional text to be appended as a text node.

Returns

{Element} An element node.

setAttributes

setAttributes: function( node,
obj )

Set multiple attributes given key value pairs from an object.

Parameters

node	{Element} An element node.
obj	{Object \|\| Array} An object whose properties represent attribute names and values represent attribute values. If an attribute name is a qualified name (“prefix:local”), the prefix will be looked up in the parsers {namespaces} object. If the prefix is found, setAttributeNS will be used instead of setAttribute.

readNode

readNode: function( node,
obj )

Shorthand for applying one of the named readers given the node namespace and local name. Readers take two args (node, obj) and generally extend or modify the second.

Parameters

node	{DOMElement} The node to be read (required).
obj	{Object} The object to be modified (optional).

Returns

{Object} The input object, modified (or a new one if none was provided).

readChildNodes

readChildNodes: function( node,
obj )

Shorthand for applying the named readers to all children of a node. For each child of type 1 (element), <readSelf> is called.

Parameters

node	{DOMElement} The node to be read (required).
obj	{Object} The object to be modified (optional).

Returns

{Object} The input object, modified.

writeNode

writeNode: function( name,
obj,
parent )

Shorthand for applying one of the named writers and appending the results to a node. If a qualified name is not provided for the second argument (and a local name is used instead), the namespace of the parent node will be assumed.

Parameters

name	{String} The name of a node to generate. If a qualified name (e.g. “pre:Name”) is used, the namespace prefix is assumed to be in the writers group. If a local name is used (e.g. “Name”) then the namespace of the parent is assumed. If a local name is used and no parent is supplied, then the default namespace is assumed.
obj	{Object} Structure containing data for the writer.
parent	{DOMElement} Result will be appended to this node. If no parent is supplied, the node will not be appended to anything.

Returns

{DOMElement} The child node.

getThisOrNextEl

getThisOrNextEl: function( node,
name,
uri )

Return this node or the next element node. Optionally get the first sibling with the given local name or namespace URI.

Parameters

node	{DOMElement} The node.
name	{String} Optional local name of the sibling to search for.
uri	{String} Optional namespace URI of the sibling to search for.

Returns

{DOMElement} The next sibling element. Returns null if no element is found, something significant besides an element is found, or the found element does not match the query.

OpenLayers. Handler

Base class to construct a higher-level handler for event sequences. All handlers have activate and deactivate methods. In addition, they have methods named like browser events. When a handler is activated, any additional methods named like a browser event is registered as a listener for the corresponding event. When a handler is deactivated, those same methods are unregistered as event listeners.

Handlers also typically have a callbacks object with keys named like the abstracted events or event sequences that they are in charge of handling. The controls that wrap handlers define the methods that correspond to these abstract events - so instead of listening for individual browser events, they only listen for the abstract events defined by the handler.

Handlers are created by controls, which ultimately have the responsibility of making changes to the the state of the application. Handlers themselves may make temporary changes, but in general are expected to return the application in the same state that they found it.

Summary

Properties
id	{String}
map	{OpenLayers.Map}
active	{Boolean}
evt	{Event} This property references the last event handled by the handler.
Functions
OpenLayers. Handler	Construct a handler.
setMap
checkModifiers	Check the keyMask on the handler.
callback	Trigger the control’s named callback with the given arguments
register	register an event on the map
unregister	unregister an event from the map
setEvent	With each registered browser event, the handler sets its own evt property.
destroy	Deconstruct the handler.
Constants
OpenLayers. Handler. MOD_NONE	If set as the <keyMask>, checkModifiers returns false if any key is down.
OpenLayers. Handler. MOD_SHIFT	If set as the <keyMask>, checkModifiers returns false if Shift is down.
OpenLayers. Handler. MOD_CTRL	If set as the <keyMask>, checkModifiers returns false if Ctrl is down.
OpenLayers. Handler. MOD_ALT	If set as the <keyMask>, checkModifiers returns false if Alt is down.

Properties

id

{String}

map

{OpenLayers.Map}

active

{Boolean}

evt

{Event} This property references the last event handled by the handler. Note that this property is not part of the stable API. Use of the evt property should be restricted to controls in the library or other applications that are willing to update with changes to the OpenLayers code.

Functions

OpenLayers. Handler

Construct a handler.

Parameters

control	{OpenLayers.Control} The control that initialized this handler. The control is assumed to have a valid map property; that map is used in the handler’s own setMap method.
callbacks	{Object} An object whose properties correspond to abstracted events or sequences of browser events. The values for these properties are functions defined by the control that get called by the handler.
options	{Object} An optional object whose properties will be set on the handler.

setMap

setMap: function ( map )

checkModifiers

checkModifiers: function ( evt )

Check the keyMask on the handler. If no <keyMask> is set, this always returns true. If a <keyMask> is set and it matches the combination of keys down on an event, this returns true.

Returns

{Boolean} The keyMask matches the keys down on an event.

callback

callback: function ( name,
args )

Trigger the control’s named callback with the given arguments

Parameters

name	{String} The key for the callback that is one of the properties of the handler’s callbacks object.
args	{Array(*)} An array of arguments (any type) with which to call the callback (defined by the control).

register

register: function ( name,
method )

unregister

unregister: function ( name,
method )

unregister an event from the map

setEvent

setEvent: function( evt )

With each registered browser event, the handler sets its own evt property. This property can be accessed by controls if needed to get more information about the event that the handler is processing.

This allows modifier keys on the event to be checked (alt, shift, and ctrl cannot be checked with the keyboard handler). For a control to determine which modifier keys are associated with the event that a handler is currently processing, it should access (code)handler.evt.altKey || handler.evt.shiftKey || handler.evt.ctrlKey(end).

Parameters

evt	{Event} The browser event.

destroy

destroy: function ()

Deconstruct the handler.

Constants

OpenLayers. Handler. MOD_NONE

If set as the <keyMask>, checkModifiers returns false if any key is down.

OpenLayers. Handler. MOD_SHIFT

If set as the <keyMask>, checkModifiers returns false if Shift is down.

OpenLayers. Handler. MOD_CTRL

If set as the <keyMask>, checkModifiers returns false if Ctrl is down.

OpenLayers. Handler. MOD_ALT

If set as the <keyMask>, checkModifiers returns false if Alt is down.

OpenLayers.Map

Instances of OpenLayers.Map are interactive maps embedded in a web page. Create a new map with the OpenLayers.Map constructor.

On their own maps do not provide much functionality. To extend a map it’s necessary to add controls (OpenLayers.Control) and layers (OpenLayers.Layer) to the map.

Summary

Constants
Z_INDEX_BASE	{Object} Base z-indexes for different classes of thing
EVENT_TYPES	{Array(String)} Supported application event types.
Properties
id	{String} Unique identifier for the map
fractionalZoom	{Boolean} For a base layer that supports it, allow the map resolution to be set to a value between one of the values in the resolutions array.
If you calling <render> after map construction, do not use	<maxResolution> auto.
dragging	{Boolean} The map is currently being dragged.
size	{OpenLayers.Size} Size of the main div (this.div)
viewPortDiv	{HTMLDivElement} The element that represents the map viewport
layerContainerOrigin	{OpenLayers.LonLat} The lonlat at which the later container was re-initialized (on-zoom)
layerContainerDiv	{HTMLDivElement} The element that contains the layers.
controls	{Array(OpenLayers.Control)} List of controls associated with the map.
popups	{Array(OpenLayers.Popup)} List of popups associated with the map
center	{OpenLayers.LonLat} The current center of the map
resolution	{Float} The resolution of the map.
zoom	{Integer} The current zoom level of the map
panRatio	{Float} The ratio of the current extent within which panning will tween.
viewRequestID	{String} Used to store a unique identifier that changes when the map view changes.
panTween	{OpenLayers.Tween} Animated panning tween object, see panTo()
panDuration	{Integer} The number of steps to be passed to the OpenLayers.Tween.start() method when the map is panned.
paddingForPopups	{OpenLayers.Bounds} Outside margin of the popup.
Functions
OpenLayers.Map	Constructor for a new OpenLayers.Map instance.
unloadDestroy	Function that is called to destroy the map on page unload.
updateSizeDestroy	When the map is destroyed, we need to stop listening to updateSize events: this method stores the function we need to unregister in non-IE browsers.
setLayerZIndex
resetLayersZIndex	Reset each layer’s z-index based on layer’s array index
addControlToMap
getCurrentSize	{OpenLayers.Size} A new OpenLayers.Size object with the dimensions of the map div
calculateBounds
moveTo
centerLayerContainer	This function takes care to recenter the layerContainerDiv.
isValidZoomLevel
isValidLonLat
getLonLatFromViewPortPx
getLonLatFromLayerPx
Constants
TILE_WIDTH	{Integer} 256 Default tile width (unless otherwise specified)
TILE_HEIGHT	{Integer} 256 Default tile height (unless otherwise specified)

Constants

Z_INDEX_BASE

{Object} Base z-indexes for different classes of thing

EVENT_TYPES

{Array(String)} Supported application event types. Register a listener for a particular event with the following syntax:

map.events.register(type, obj, listener);

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 map.events.object.
element {DOMElement} A reference to map.events.element.

Browser events have the following additional properties

xy {OpenLayers.Pixel} The pixel location of the event (relative to the the map viewport).
other properties that come with browser events

Supported map event types

preaddlayer triggered before a layer has been added. The event object will include a layer property that references the layer to be added.
addlayer triggered after a layer has been added. The event object will include a layer property that references the added layer.
removelayer triggered after a layer has been removed. The event object will include a layer property that references the removed layer.
changelayer triggered after a layer name change, order change, or visibility change (due to resolution thresholds). Listeners will receive an event object with layer and property properties. The layer property will be a reference to the changed layer. The property property will be a key to the changed property (name, visibility, or order).
movestart triggered after the start of a drag, pan, or zoom
move triggered after each drag, pan, or zoom
moveend triggered after a drag, pan, or zoom completes
zoomend triggered after a zoom completes
addmarker triggered after a marker has been added
removemarker triggered after a marker has been removed
clearmarkers triggered after markers have been cleared
mouseover triggered after mouseover the map
mouseout triggered after mouseout the map
mousemove triggered after mousemove the map
dragstart Does not work. Register for movestart instead.
drag Does not work. Register for move instead.
dragend Does not work. Register for moveend instead.
changebaselayer triggered after the base layer changes

Properties

id

{String} Unique identifier for the map

fractionalZoom

{Boolean} For a base layer that supports it, allow the map resolution to be set to a value between one of the values in the resolutions array. Default is false.

When fractionalZoom is set to true, it is possible to zoom to an arbitrary extent. This requires a base layer from a source that supports requests for arbitrary extents (i.e. not cached tiles on a regular lattice). This means that fractionalZoom will not work with commercial layers (Google, Yahoo, VE), layers using TileCache, or any other pre-cached data sources.

If you are using fractionalZoom, then you should also use <getResolutionForZoom> instead of layer.resolutions[zoom] as the former works for non-integer zoom levels.

If you calling <render> after map construction, do not use

<maxResolution> auto. Instead, divide your <maxExtent> by your maximum expected dimension.

dragging

{Boolean} The map is currently being dragged.

size

{OpenLayers.Size} Size of the main div (this.div)

viewPortDiv

{HTMLDivElement} The element that represents the map viewport

layerContainerOrigin

{OpenLayers.LonLat} The lonlat at which the later container was re-initialized (on-zoom)

layerContainerDiv

{HTMLDivElement} The element that contains the layers.

controls

{Array(OpenLayers.Control)} List of controls associated with the map.

If not provided in the map options at construction, the map will be given the following controls by default:

OpenLayers.Control.Navigation
OpenLayers.Control.PanZoom
OpenLayers.Control.ArgParser
<OpenLayers.Control.Attribution>

popups

{Array(OpenLayers.Popup)} List of popups associated with the map

center

{OpenLayers.LonLat} The current center of the map

resolution

{Float} The resolution of the map.

zoom

{Integer} The current zoom level of the map

panRatio

{Float} The ratio of the current extent within which panning will tween.

viewRequestID

{String} Used to store a unique identifier that changes when the map view changes. viewRequestID should be used when adding data asynchronously to the map: viewRequestID is incremented when you initiate your request (right now during changing of baselayers and changing of zooms). It is stored here in the map and also in the data that will be coming back asynchronously. Before displaying this data on request completion, we check that the viewRequestID of the data is still the same as that of the map. Fix for #480

panTween

{OpenLayers.Tween} Animated panning tween object, see panTo()

panDuration

{Integer} The number of steps to be passed to the OpenLayers.Tween.start() method when the map is panned. Default is 50.

paddingForPopups

{OpenLayers.Bounds} Outside margin of the popup. Used to prevent the popup from getting too close to the map border.

Functions

OpenLayers.Map

Constructor for a new OpenLayers.Map instance. There are two possible ways to call the map constructor. See the examples below.

Parameters

div	{String} Id of an element in your page that will contain the map. May be omitted if the <div> option is provided or if you intend to use <render> later.
options	{Object} Optional object with properties to tag onto the map.

Examples (method one)

// create a map with default options in an element with the id "map1"
var map = new OpenLayers.Map("map1");

// create a map with non-default options in an element with id "map2"
var options = {
    maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000),
    maxResolution: 156543,
    units: 'm',
    projection: "EPSG:41001"
};
var map = new OpenLayers.Map("map2", options);

Examples (method two

single argument):

// create a map with non-default options
var map = new OpenLayers.Map({
    div: "map_id",
    maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000),
    maxResolution: 156543,
    units: 'm',
    projection: "EPSG:41001"
});

// create a map without a reference to a container - call render later
var map = new OpenLayers.Map({
    maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000),
    maxResolution: 156543,
    units: 'm',
    projection: "EPSG:41001"
});

unloadDestroy

Function that is called to destroy the map on page unload. stored here so that if map is manually destroyed, we can unregister this.

updateSizeDestroy

When the map is destroyed, we need to stop listening to updateSize events: this method stores the function we need to unregister in non-IE browsers.

setLayerZIndex

setLayerZIndex: function ( layer,
zIdx )

Parameters

layer	{OpenLayers.Layer}
zIdx	{int}

resetLayersZIndex

resetLayersZIndex: function()

Reset each layer’s z-index based on layer’s array index

addControlToMap

addControlToMap: function ( control,
px )

Parameters

control	{OpenLayers.Control}
px	{OpenLayers.Pixel}

getCurrentSize

getCurrentSize: function()

Returns

{OpenLayers.Size} A new OpenLayers.Size object with the dimensions of the map div

calculateBounds

calculateBounds: function( center,
resolution )

Parameters

center	{OpenLayers.LonLat} Default is this.getCenter()
resolution	{float} Default is this.getResolution()

Returns

{OpenLayers.Bounds} A bounds based on resolution, center, and current mapsize.

moveTo

moveTo: function( lonlat,
zoom,
options )

Parameters

lonlat	{OpenLayers.LonLat}
zoom	{Integer}
options	{Object}

centerLayerContainer

centerLayerContainer: function ( lonlat )

This function takes care to recenter the layerContainerDiv.

Parameters

lonlat

isValidZoomLevel

isValidZoomLevel: function( zoomLevel )

Parameters

zoomLevel

{Integer}

Returns

{Boolean} Whether or not the zoom level passed in is non-null and within the min/max range of zoom levels.

isValidLonLat

isValidLonLat: function( lonlat )

Parameters

lonlat

Returns

{Boolean} Whether or not the lonlat passed in is non-null and within the maxExtent bounds

getLonLatFromViewPortPx

getLonLatFromViewPortPx: function ( viewPortPx )

Parameters

viewPortPx

Returns

{OpenLayers.LonLat} An OpenLayers.LonLat which is the passed-in view port OpenLayers.Pixel, translated into lon/lat by the current base layer.

getLonLatFromLayerPx

getLonLatFromLayerPx: function ( px )

Parameters

px	{OpenLayers.Pixel}

Returns

Constants

TILE_WIDTH

{Integer} 256 Default tile width (unless otherwise specified)

TILE_HEIGHT

{Integer} 256 Default tile height (unless otherwise specified)

OpenLayers. Marker

Instances of OpenLayers.Marker are a combination of a OpenLayers.LonLat and an OpenLayers.Icon.

Markers are generally added to a special layer called OpenLayers.Layer.Markers.

Example

var markers = new OpenLayers.Layer.Markers( "Markers" );
map.addLayer(markers);

var size = new OpenLayers.Size(10,17);
var offset = new OpenLayers.Pixel(-(size.w/2), -size.h);
var icon = new OpenLayers.Icon('http://boston.openguides.org/markers/AQUA.png',size,offset);
markers.addMarker(new OpenLayers.Marker(new OpenLayers.LonLat(0,0),icon));
markers.addMarker(new OpenLayers.Marker(new OpenLayers.LonLat(0,0),icon.clone()));

Note that if you pass an icon into the Marker constructor, it will take that icon and use it. This means that you should not share icons between markers -- you use them once, but you should clone() for any additional markers using that same icon.

Summary

Properties
icon	{OpenLayers.Icon} The icon used by this marker.
lonlat	{OpenLayers.LonLat} location of object
events	{OpenLayers.Events} the event handler.
map	{OpenLayers.Map} the map this marker is attached to
Functions
OpenLayers. Marker
draw	Calls draw on the icon, and returns that output.
erase	Erases any drawn elements for this marker.
moveTo	Move the marker to the new location.
onScreen	{Boolean} Whether or not the marker is currently visible on screen.
inflate	Englarges the markers icon by the specified ratio.
setOpacity	Change the opacity of the marker by changin the opacity of its icon
setUrl	Change URL of the Icon Image.
display	Hide or show the icon
defaultIcon	Creates a default OpenLayers.Icon.

Properties

icon

{OpenLayers.Icon} The icon used by this marker.

lonlat

{OpenLayers.LonLat} location of object

events

{OpenLayers.Events} the event handler.

map

{OpenLayers.Map} the map this marker is attached to

Functions

OpenLayers. Marker

Parameters

lonlat	{OpenLayers.LonLat} the position of this marker
icon	{OpenLayers.Icon} the icon for this marker

draw

draw: function( px )

Calls draw on the icon, and returns that output.

Parameters

px	{OpenLayers.Pixel}

Returns

{DOMElement} A new DOM Image with this marker’s icon set at the location passed-in

erase

erase: function()

Erases any drawn elements for this marker.

moveTo

moveTo: function ( px )

Move the marker to the new location.

Parameters

px	{OpenLayers.Pixel} the pixel position to move to

onScreen

onScreen:function()

Returns

{Boolean} Whether or not the marker is currently visible on screen.

inflate

inflate: function( inflate )

Englarges the markers icon by the specified ratio.

Parameters

inflate

{float} the ratio to enlarge the marker by (passing 2 will double the size).

setOpacity

setOpacity: function( opacity )

Change the opacity of the marker by changin the opacity of its icon

Parameters

opacity

{float} Specified as fraction (0.4, etc)

setUrl

setUrl: function( url )

Change URL of the Icon Image.

url

{String}

display

display: function( display )

Hide or show the icon

display

{Boolean}

defaultIcon

OpenLayers.Marker.defaultIcon = function()

Creates a default OpenLayers.Icon.

Returns

{OpenLayers.Icon} A default OpenLayers.Icon to use for a marker

OpenLayers. Request

The OpenLayers.Request namespace contains convenience methods for working with XMLHttpRequests. These methods work with a cross-browser W3C compliant OpenLayers.Request.XMLHttpRequest class.

Summary

Constants
DEFAULT_CONFIG	{Object} Default configuration for all requests.

Constants

DEFAULT_CONFIG

{Object} Default configuration for all requests.

OpenLayers. Tile. Image

Instances of OpenLayers.Tile.Image are used to manage the image tiles used by various layers. Create a new image tile with the OpenLayers.Tile.Image constructor.

Inherits from

OpenLayers.Tile

Summary

Properties
url	{String} The URL of the image being requested.
imgDiv	{DOMElement} The div element which wraps the image.
frame	{DOMElement} The image element is appended to the frame.
layerAlphaHack	{Boolean} True if the png alpha hack needs to be applied on the layer’s div.
isBackBuffer	{Boolean} Is this tile a back buffer tile?
lastRatio	{Float} Used in transition code only.
isFirstDraw	{Boolean} Is this the first time the tile is being drawn?
backBufferTile	{OpenLayers.Tile} A clone of the tile used to create transition effects when the tile is moved or changes resolution.
Functions
OpenLayers. Tile. Image	Constructor for a new OpenLayers.Tile.Image instance.
clone
draw	Check that a tile should be drawn, and draw it.
resetBackBuffer	Triggered by two different events, layer loadend, and tile loadend.
renderTile	Internal function to actually initialize the image tile, position it correctly, and set its url.
positionImage	Using the properties currenty set on the layer, position the tile correctly.
clear	Clear the tile of any bounds/position-related data so that it can be reused in a new location.
initImgDiv	Creates the imgDiv property on the tile.
checkImgURL	Make sure that the image that just loaded is the one this tile is meant to display, since panning/zooming might have changed the tile’s URL in the meantime.
startTransition	This method is invoked on tiles that are backBuffers for tiles in the grid.
show	Show the tile by showing its frame.
hide	Hide the tile by hiding its frame.

Properties

url

{String} The URL of the image being requested. No default. Filled in by layer.getURL() function.

imgDiv

{DOMElement} The div element which wraps the image.

frame

{DOMElement} The image element is appended to the frame. Any gutter on the image will be hidden behind the frame.

layerAlphaHack

{Boolean} True if the png alpha hack needs to be applied on the layer’s div.

isBackBuffer

{Boolean} Is this tile a back buffer tile?

lastRatio

{Float} Used in transition code only. This is the previous ratio of the back buffer tile resolution to the map resolution. Compared with the current ratio to determine if zooming occurred.

isFirstDraw

{Boolean} Is this the first time the tile is being drawn? This is used to force resetBackBuffer to synchronize the backBufferTile with the foreground tile the first time the foreground tile loads so that if the user zooms before the layer has fully loaded, the backBufferTile for tiles that have been loaded can be used.

backBufferTile

{OpenLayers.Tile} A clone of the tile used to create transition effects when the tile is moved or changes resolution.

Functions

OpenLayers. Tile. Image

Constructor for a new OpenLayers.Tile.Image instance.

Parameters

layer	{OpenLayers.Layer} layer that the tile will go in.
position	{OpenLayers.Pixel}
bounds	{OpenLayers.Bounds}
url	{String} Deprecated. Remove me in 3.0.
size	{OpenLayers.Size}

clone

clone: function ( obj )

Parameters

obj	{OpenLayers.Tile.Image} The tile to be cloned

Returns

{OpenLayers.Tile.Image} An exact clone of this OpenLayers.Tile.Image

draw

draw: function()

Check that a tile should be drawn, and draw it.

Returns

{Boolean} Always returns true.

resetBackBuffer

resetBackBuffer: function()

Triggered by two different events, layer loadend, and tile loadend. In any of these cases, we check to see if we can hide the backBufferTile yet and update its parameters to match the foreground tile.

Basic logic

If the backBufferTile hasn’t been drawn yet, reset it
If layer is still loading, show foreground tile but don’t hide the backBufferTile yet
If layer is done loading, reset backBuffer tile and show foreground tile

renderTile

renderTile: function()

Internal function to actually initialize the image tile, position it correctly, and set its url.

positionImage

positionImage: function()

Using the properties currenty set on the layer, position the tile correctly. This method is used both by the async and non-async versions of the Tile.Image code.

clear

clear: function()

Clear the tile of any bounds/position-related data so that it can be reused in a new location.

initImgDiv

initImgDiv: function()

Creates the imgDiv property on the tile.

checkImgURL

checkImgURL: function ()

Make sure that the image that just loaded is the one this tile is meant to display, since panning/zooming might have changed the tile’s URL in the meantime. If the tile URL did change before the image loaded, set the imgDiv display to ‘none’, as either (a) it will be reset to visible when the new URL loads in the image, or (b) we don’t want to display this tile after all because its new bounds are outside our maxExtent.

This function should no longer be neccesary with the improvements to Grid.js in OpenLayers 2.3. The lack of a good isEquivilantURL function caused problems in 2.2, but it’s possible that with the improved isEquivilant URL function, this might be neccesary at some point.

See discussion in the thread at http://openlayers.org- /pipermail- /dev- /2007-January- /000205.html

startTransition

startTransition: function()

This method is invoked on tiles that are backBuffers for tiles in the grid. The grid tile is about to be cleared and a new tile source loaded. This is where the transition effect needs to be started to provide visual continuity.

show

show: function()

Show the tile by showing its frame.

hide

hide: function()

Hide the tile by hiding its frame.

OpenLayers. Control. OverviewMap

The OverMap control creates a small overview map, useful to display the extent of a zoomed map and your main map and provide additional navigation options to the User. By default the overview map is drawn in the lower right corner of the main map. Create a new overview map with the OpenLayers.Control.OverviewMap constructor.

Inerits from

OpenLayers.Control

Summary

Properties
element	{DOMElement} The DOM element that contains the overview map
handlers	{Object}
resolutionFactor	{Object}
Functions
OpenLayers. Control. OverviewMap	Create a new overview map
draw	Render the control in the browser.
baseLayerDraw
rectDrag	Handle extent rectangle drag
mapDivClick	Handle browser events
maximizeControl	Unhide the control.
minimizeControl	Hide all the contents of the control, shrink the size, add the maximize icon
showToggle	Hide/Show the toggle depending on whether the control is minimized
update	Update the overview map after layers move.
isSuitableOverview	Determines if the overview map is suitable given the extent and resolution of the main map.
createMap	Construct the map that this control contains
updateRectToMap	Updates the extent rectangle position and size to match the map extent
updateMapToRect	Updates the map extent to match the extent rectangle position and size
setRectPxBounds	Set extent rectangle pixel bounds.
getRectBoundsFromMapBounds	Get the rect bounds from the map bounds.
getMapBoundsFromRectBounds	Get the map bounds from the rect bounds.
getLonLatFromOverviewPx	Get a map location from a pixel location
getOverviewPxFromLonLat	Get a pixel location from a map location

Properties

element

{DOMElement} The DOM element that contains the overview map

handlers

{Object}

resolutionFactor

{Object}

Functions

OpenLayers. Control. OverviewMap

Create a new overview map

Parameters

object

{Object} Properties of this object will be set on the overview map object. Note, to set options on the map object contained in this control, set <mapOptions> as one of the options properties.

draw

draw: function()

Render the control in the browser.

baseLayerDraw

baseLayerDraw: function()

Draw the base layer

called if unable to complete in the initial draw

rectDrag

rectDrag: function( px )

Handle extent rectangle drag

Parameters

px	{OpenLayers.Pixel} The pixel location of the drag.

mapDivClick

mapDivClick: function( evt )

Handle browser events

Parameters

evt	{OpenLayers.Event} evt

maximizeControl

maximizeControl: function( e )

Unhide the control. Called when the control is in the map viewport.

Parameters

e	{OpenLayers.Event}

minimizeControl

minimizeControl: function( e )

Hide all the contents of the control, shrink the size, add the maximize icon

Parameters

e	{OpenLayers.Event}

showToggle

showToggle: function( minimize )

Hide/Show the toggle depending on whether the control is minimized

Parameters

minimize

{Boolean}

update

update: function()

Update the overview map after layers move.

isSuitableOverview

isSuitableOverview: function()

Determines if the overview map is suitable given the extent and resolution of the main map.

createMap

createMap: function()

Construct the map that this control contains

updateRectToMap

updateRectToMap: function()

Updates the extent rectangle position and size to match the map extent

updateMapToRect

updateMapToRect: function()

Updates the map extent to match the extent rectangle position and size

setRectPxBounds

setRectPxBounds: function( pxBounds )

Set extent rectangle pixel bounds.

Parameters

pxBounds

getRectBoundsFromMapBounds

getRectBoundsFromMapBounds: function( lonLatBounds )

Get the rect bounds from the map bounds.

Parameters

lonLatBounds

Returns

{OpenLayers.Bounds}A bounds which is the passed-in map lon/lat extent translated into pixel bounds for the overview map

getMapBoundsFromRectBounds

getMapBoundsFromRectBounds: function( pxBounds )

Get the map bounds from the rect bounds.

Parameters

pxBounds

Returns

{OpenLayers.Bounds} Bounds which is the passed-in overview rect bounds translated into lon/lat bounds for the overview map

getLonLatFromOverviewPx

getLonLatFromOverviewPx: function( overviewMapPx )

Get a map location from a pixel location

Parameters

overviewMapPx

Returns

{OpenLayers.LonLat} Location which is the passed-in overview map OpenLayers.Pixel, translated into lon/lat by the overview map

getOverviewPxFromLonLat

getOverviewPxFromLonLat: function( lonlat )

Get a pixel location from a map location

Parameters

lonlat

Returns

{OpenLayers.Pixel} Location which is the passed-in OpenLayers.LonLat, translated into overview map pixels

OpenLayers. Feature

Features are combinations of geography and attributes. The OpenLayers.Feature class specifically combines a marker and a lonlat.

Summary

Properties
layer	{OpenLayers.Layer}
id	{String}
lonlat	{OpenLayers.LonLat}
data	{Object}
marker	{OpenLayers.Marker}
popup	{OpenLayers.Popup}
Functions
OpenLayers. Feature	Constructor for features.
destroy	nullify references to prevent circular references and memory leaks
onScreen	{Boolean} Whether or not the feature is currently visible on screen (based on its ‘lonlat’ property)
createMarker	Based on the data associated with the Feature, create and return a marker object.
destroyMarker	Destroys marker.
createPopup	Creates a popup object created from the ‘lonlat’, ‘popupSize’, and ‘popupContentHTML’ properties set in this.data.
destroyPopup	Destroys the popup created via createPopup.

Properties

layer

{OpenLayers.Layer}

id

{String}

lonlat

data

{Object}

marker

{OpenLayers.Marker}

popup

{OpenLayers.Popup}

Functions

OpenLayers. Feature

Constructor for features.

Parameters

layer	{OpenLayers.Layer}
lonlat	{OpenLayers.LonLat}
data	{Object}

Returns

{OpenLayers.Feature}

destroy

destroy: function()

nullify references to prevent circular references and memory leaks

onScreen

onScreen:function()

Returns

{Boolean} Whether or not the feature is currently visible on screen (based on its ‘lonlat’ property)

createMarker

createMarker: function()

Based on the data associated with the Feature, create and return a marker object.

Returns

{OpenLayers.Marker} A Marker Object created from the ‘lonlat’ and ‘icon’ properties set in this.data. If no ‘lonlat’ is set, returns null. If no ‘icon’ is set, OpenLayers.Marker() will load the default image.

Note	this.marker is set to return value

destroyMarker

destroyMarker: function()

Destroys marker. If user overrides the createMarker() function, s/he should be able to also specify an alternative function for destroying it

createPopup

createPopup: function( closeBox )

Creates a popup object created from the ‘lonlat’, ‘popupSize’, and ‘popupContentHTML’ properties set in this.data. It uses this.marker.icon as default anchor.

If no ‘lonlat’ is set, returns null. If no this.marker has been created, no anchor is sent.

Note	the returned popup object is ‘owned’ by the feature, so you cannot use the popup’s destroy method to discard the popup. Instead, you must use the feature’s destroyPopup
Note	this.popup is set to return value

Parameters

closeBox

{Boolean} create popup with closebox or not

Returns

{OpenLayers.Popup} Returns the created popup, which is also set as ‘popup’ property of this feature. Will be of whatever type specified by this feature’s ‘popupClass’ property, but must be of type OpenLayers.Popup.

destroyPopup

destroyPopup: function()

Destroys the popup created via createPopup.

As with the marker, if user overrides the createPopup() function, s/he should also be able to override the destruction

OpenLayers. Handler. Click

A handler for mouse clicks. The intention of this handler is to give controls more flexibility with handling clicks. Browsers trigger click events twice for a double-click. In addition, the mousedown, mousemove, mouseup sequence fires a click event. With this handler, controls can decide whether to ignore clicks associated with a double click. By setting a <pixelTolerance>, controls can also ignore clicks that include a drag. Create a new instance with the OpenLayers.Handler.Click constructor.

Inherits from

OpenLayers.Handler

Summary

Properties
timerId	{Number} The id of the timeout waiting to clear the delayedCall.
down	{OpenLayers.Pixel} The pixel location of the last mousedown.
rightclickTimerId	{Number} The id of the right mouse timeout waiting to clear the <delayedEvent>.
Functions
OpenLayers. Handler. Click	Create a new click handler.
mousedown	Handle mousedown.
mouseup	Handle mouseup.
rightclick	Handle rightclick.
delayedRightCall	Sets rightclickTimerId to null.
dblclick	Handle dblclick.
click	Handle click.
passesTolerance	Determine whether the event is within the optional pixel tolerance.
clearTimer	Clear the timer and set timerId to null.
delayedCall	Sets timerId to null.

Properties

timerId

{Number} The id of the timeout waiting to clear the delayedCall.

down

{OpenLayers.Pixel} The pixel location of the last mousedown.

rightclickTimerId

{Number} The id of the right mouse timeout waiting to clear the <delayedEvent>.

Functions

OpenLayers. Handler. Click

Create a new click handler.

Parameters

control	{OpenLayers.Control} The control that is making use of this handler. If a handler is being used without a control, the handler’s setMap method must be overridden to deal properly with the map.
callbacks	{Object} An object with keys corresponding to callbacks that will be called by the handler. The callbacks should expect to recieve a single argument, the click event. Callbacks for ‘click’ and ‘dblclick’ are supported.
options	{Object} Optional object whose properties will be set on the handler.

delayedRightCall: function( evt )

Sets rightclickTimerId to null. And optionally triggers the rightclick callback if evt is set.

dblclick

dblclick: function( evt )

Handle dblclick. For a dblclick, we get two clicks in some browsers (FF) and one in others (IE). So we need to always register for dblclick to properly handle single clicks.

Returns

{Boolean} Continue propagating this event.

click

click: function( evt )

Handle click.

Returns

{Boolean} Continue propagating this event.

passesTolerance

passesTolerance: function( evt )

Determine whether the event is within the optional pixel tolerance. Note that the pixel tolerance check only works if mousedown events get to the listeners registered here. If they are stopped by other elements, the <pixelTolerance> will have no effect here (this method will always return true).

Returns

{Boolean} The click is within the pixel tolerance (if specified).

clearTimer

clearTimer: function()

Clear the timer and set timerId to null.

delayedCall

delayedCall: function( evt )

Sets timerId to null. And optionally triggers the click callback if evt is set.

OpenLayers. Handler.Drag

The drag handler is used to deal with sequences of browser events related to dragging. The handler is used by controls that want to know when a drag sequence begins, when a drag is happening, and when it has finished.

Controls that use the drag handler typically construct it with callbacks for ‘down’, ‘move’, and ‘done’. Callbacks for these keys are called when the drag begins, with each move, and when the drag is done. In addition, controls can have callbacks keyed to ‘up’ and ‘out’ if they care to differentiate between the types of events that correspond with the end of a drag sequence. If no drag actually occurs (no mouse move) the ‘down’ and ‘up’ callbacks will be called, but not the ‘done’ callback.

Create a new drag handler with the OpenLayers.Handler.Drag constructor.

Inherits from

OpenLayers.Handler

Summary

Properties
started	{Boolean} When a mousedown event is received, we want to record it, but not set ‘dragging’ until the mouse moves after starting.
stopDown	{Boolean} Stop propagation of mousedown events from getting to listeners on the same element.
dragging	{Boolean}
last	{OpenLayers.Pixel} The last pixel location of the drag.
start	{OpenLayers.Pixel} The first pixel location of the drag.
oldOnselectstart	{Function}
interval	{Integer} In order to increase performance, an interval (in milliseconds) can be set to reduce the number of drag events called.
timeoutId	{String} The id of the timeout used for the mousedown interval.
Functions
OpenLayers. Handler.Drag	Returns OpenLayers.Handler.Drag
down	This method is called during the handling of the mouse down event.
move	This method is called during the handling of the mouse move event.
up	This method is called during the handling of the mouse up event.
out	This method is called during the handling of the mouse out event.
mousedown	Handle mousedown events
mousemove	Handle mousemove events
removeTimeout	Private.
mouseup	Handle mouseup events
mouseout	Handle mouseout events
click	The drag handler captures the click event.
activate	Activate the handler.
deactivate	Deactivate the handler.

Properties

started

{Boolean} When a mousedown event is received, we want to record it, but not set ‘dragging’ until the mouse moves after starting.

stopDown

{Boolean} Stop propagation of mousedown events from getting to listeners on the same element. Default is true.

dragging

{Boolean}

last

{OpenLayers.Pixel} The last pixel location of the drag.

start

{OpenLayers.Pixel} The first pixel location of the drag.

oldOnselectstart

{Function}

interval

{Integer} In order to increase performance, an interval (in milliseconds) can be set to reduce the number of drag events called. If set, a new drag event will not be set until the interval has passed. Defaults to 0, meaning no interval.

timeoutId

{String} The id of the timeout used for the mousedown interval. This is “private”, and should be left alone.

Functions

OpenLayers. Handler.Drag

Returns OpenLayers.Handler.Drag

Parameters

control	{OpenLayers.Control} The control that is making use of this handler. If a handler is being used without a control, the handlers setMap method must be overridden to deal properly with the map.
callbacks	{Object} An object containing a single function to be called when the drag operation is finished. The callback should expect to recieve a single argument, the pixel location of the event. Callbacks for ‘move’ and ‘done’ are supported. You can also speficy callbacks for ‘down’, ‘up’, and ‘out’ to respond to those events.
options	{Object}

down

down: function( evt )

This method is called during the handling of the mouse down event. Subclasses can do their own processing here.

Parameters

evt	{Event} The mouse down event

move

move: function( evt )

This method is called during the handling of the mouse move event. Subclasses can do their own processing here.

Parameters

evt	{Event} The mouse move event

up

up: function( evt )

This method is called during the handling of the mouse up event. Subclasses can do their own processing here.

Parameters

evt	{Event} The mouse up event

out

out: function( evt )

This method is called during the handling of the mouse out event. Subclasses can do their own processing here.

Parameters

evt	{Event} The mouse out event

mousedown

mousedown: function ( evt )

Handle mousedown events

Parameters

evt

{Event}

Returns

{Boolean} Let the event propagate.

mousemove

mousemove: function ( evt )

Handle mousemove events

Parameters

evt

{Event}

Returns

{Boolean} Let the event propagate.

removeTimeout

removeTimeout: function()

Private. Called by mousemove() to remove the drag timeout.

mouseup

mouseup: function ( evt )

Handle mouseup events

Parameters

evt

{Event}

Returns

{Boolean} Let the event propagate.

mouseout

mouseout: function ( evt )

Handle mouseout events

Parameters

evt

{Event}

Returns

{Boolean} Let the event propagate.

click

click: function ( evt )

The drag handler captures the click event. If something else registers for clicks on the same element, its listener will not be called after a drag.

Parameters

evt

{Event}

Returns

{Boolean} Let the event propagate.

activate

activate: function()

Activate the handler.

Returns

{Boolean} The handler was successfully activated.

deactivate

deactivate: function()

Deactivate the handler.

Returns

{Boolean} The handler was successfully deactivated.

OpenLayers. Handler. Feature

Handler to respond to mouse events related to a drawn feature. Callbacks with the following keys will be notified of the following events associated with features: click, clickout, over, out, and dblclick.

This handler stops event propagation for mousedown and mouseup if those browser events target features that can be selected.

Summary

Properties
EVENTMAP	{Object} A object mapping the browser events to objects with callback keys for in and out.
feature	{OpenLayers.Feature.Vector} The last feature that was hovered.
lastFeature	{OpenLayers.Feature.Vector} The last feature that was handled.
down	{OpenLayers.Pixel} The location of the last mousedown.
up	{OpenLayers.Pixel} The location of the last mouseup.
clickTolerance	{Number} The number of pixels the mouse can move between mousedown and mouseup for the event to still be considered a click.
geometryTypes	To restrict dragging to a limited set of geometry types, send a list of strings corresponding to the geometry class names.
stopClick	{Boolean} If stopClick is set to true, handled clicks do not propagate to other click listeners.
stopDown	{Boolean} If stopDown is set to true, handled mousedowns do not propagate to other mousedown listeners.
stopUp	{Boolean} If stopUp is set to true, handled mouseups do not propagate to other mouseup listeners.
Functions
OpenLayers. Handler. Feature
mousedown	Handle mouse down.
mouseup	Handle mouse up.
click	Handle click.
mousemove	Handle mouse moves.
dblclick	Handle dblclick.
geometryTypeMatches	Return true if the geometry type of the passed feature matches one of the geometry types in the geometryTypes array.
handle
triggerCallback	Call the callback keyed in the event map with the supplied arguments.
activate	Turn on the handler.
deactivate	Turn off the handler.
moveLayerToTop	Moves the layer for this handler to the top, so mouse events can reach it.
moveLayerBack	Moves the layer back to the position determined by the map’s layers array.

Properties

EVENTMAP

{Object} A object mapping the browser events to objects with callback keys for in and out.

feature

{OpenLayers.Feature.Vector} The last feature that was hovered.

lastFeature

{OpenLayers.Feature.Vector} The last feature that was handled.

down

{OpenLayers.Pixel} The location of the last mousedown.

up

{OpenLayers.Pixel} The location of the last mouseup.

clickTolerance

{Number} The number of pixels the mouse can move between mousedown and mouseup for the event to still be considered a click. Dragging the map should not trigger the click and clickout callbacks unless the map is moved by less than this tolerance. Defaults to 4.

geometryTypes

To restrict dragging to a limited set of geometry types, send a list of strings corresponding to the geometry class names.

@type Array(String)

stopClick

{Boolean} If stopClick is set to true, handled clicks do not propagate to other click listeners. Otherwise, handled clicks do propagate. Unhandled clicks always propagate, whatever the value of stopClick. Defaults to true.

stopDown

{Boolean} If stopDown is set to true, handled mousedowns do not propagate to other mousedown listeners. Otherwise, handled mousedowns do propagate. Unhandled mousedowns always propagate, whatever the value of stopDown. Defaults to true.

stopUp

{Boolean} If stopUp is set to true, handled mouseups do not propagate to other mouseup listeners. Otherwise, handled mouseups do propagate. Unhandled mouseups always propagate, whatever the value of stopUp. Defaults to false.

Functions

OpenLayers. Handler. Feature

Parameters

control	{OpenLayers.Control}
layer	{OpenLayers.Layer.Vector}
callbacks	{Object} An object with a ‘over’ property whos value is a function to be called when the mouse is over a feature. The callback should expect to recieve a single argument, the feature.
options	{Object}

mousedown

mousedown: function( evt )

Handle mouse down. Stop propagation if a feature is targeted by this event (stops map dragging during feature selection).

Parameters

evt

{Event}

mouseup

mouseup: function( evt )

Handle mouse up. Stop propagation if a feature is targeted by this event.

Parameters

evt

{Event}

click

click: function( evt )

Handle click. Call the “click” callback if click on a feature, or the “clickout” callback if click outside any feature.

Parameters

evt

{Event}

Returns

{Boolean}

mousemove

mousemove: function( evt )

Handle mouse moves. Call the “over” callback if moving in to a feature, or the “out” callback if moving out of a feature.

Parameters

evt

{Event}

Returns

{Boolean}

dblclick

dblclick: function( evt )

Handle dblclick. Call the “dblclick” callback if dblclick on a feature.

Parameters

evt

{Event}

Returns

{Boolean}

geometryTypeMatches

geometryTypeMatches: function( feature )

Return true if the geometry type of the passed feature matches one of the geometry types in the geometryTypes array.

Parameters

feature

{<OpenLayers.Vector.Feature>}

Returns

{Boolean}

handle

handle: function( evt )

Parameters

evt

{Event}

Returns

{Boolean} The event occurred over a relevant feature.

triggerCallback

triggerCallback: function( type,
mode,
args )

Call the callback keyed in the event map with the supplied arguments. For click and clickout, the clickTolerance is checked first.

Parameters

type

{String}

activate

activate: function()

Turn on the handler. Returns false if the handler was already active.

Returns

{Boolean}

deactivate

deactivate: function()

Turn off the handler. Returns false if the handler was already active.

Returns

{Boolean}

moveLayerToTop

moveLayerToTop: function()

Moves the layer for this handler to the top, so mouse events can reach it.

moveLayerBack

moveLayerBack: function()

Moves the layer back to the position determined by the map’s layers array.

OpenLayers. Handler. Hover

The hover handler is to be used to emulate mouseovers on objects on the map that aren’t DOM elements. For example one can use this handler to send WMS/GetFeatureInfo requests as the user moves the mouve over the map.

Inherits from

OpenLayers.Handler

Summary

Properties
px
timerId
Functions
OpenLayers. Handler. Hover	Construct a hover handler.
mousemove	Called when the mouse moves on the map.
mouseout	Called when the mouse goes out of the map.
passesTolerance	Determine whether the mouse move is within the optional pixel tolerance.
clearTimer	Clear the timer and set timerId to null.
delayedCall	Triggers pause callback.

Properties

px

{<OpenLayers.Pixel>}

The location of the last mousemove, expressed in pixels.

timerId

{Number}

The id of the timer.

Functions

OpenLayers. Handler. Hover

Construct a hover handler.

Parameters

control	{OpenLayers.Control} The control that initialized this handler. The control is assumed to have a valid map property; that map is used in the handler’s own setMap method.
callbacks	{Object} An object with keys corresponding to callbacks that will be called by the handler. The callbacks should expect to receive a single argument, the event. Callbacks for ‘move’, the mouse is moving, and ‘pause’, the mouse is pausing, are supported.
options	{Object} An optional object whose properties will be set on the handler.

mousemove

mousemove: function( evt )

Called when the mouse moves on the map.

Parameters

evt	{OpenLayers.Event}

Returns

{Boolean} Continue propagating this event.

mouseout

mouseout: function( evt )

Called when the mouse goes out of the map.

Parameters

evt	{OpenLayers.Event}

Returns

{Boolean} Continue propagating this event.

passesTolerance

passesTolerance: function( px )

Determine whether the mouse move is within the optional pixel tolerance.

Parameters

px	{OpenLayers.Pixel}

Returns

{Boolean} The mouse move is within the pixel tolerance.

clearTimer

clearTimer: function()

Clear the timer and set timerId to null.

delayedCall

delayedCall: function( evt )

Triggers pause callback.

Parameters

evt	{OpenLayers.Event}

OpenLayers. Handler. MouseWheel

Handler for wheel up/down events.

Inherits from

OpenLayers.Handler

Summary

Properties
wheelListener	{function}
mousePosition	{OpenLayers.Pixel} mousePosition is necessary because evt.clientX/Y is buggy in Moz on wheel events, so we cache and use the value from the last mousemove.
Functions
OpenLayers. Handler. MouseWheel
destroy
onWheelEvent	Catch the wheel event and handle it xbrowserly
wheelZoom	Given the wheel event, we carry out the appropriate zooming in or out, based on the ‘wheelDelta’ or ‘detail’ property of the event.
mousemove	Update the stored mousePosition on every move.
activate
deactivate

Properties

wheelListener

{function}

mousePosition

{OpenLayers.Pixel} mousePosition is necessary because evt.clientX/Y is buggy in Moz on wheel events, so we cache and use the value from the last mousemove.

Functions

OpenLayers. Handler. MouseWheel

Parameters

control	{OpenLayers.Control}
callbacks	{Object} An object containing a single function to be called when the drag operation is finished. The callback should expect to recieve a single argument, the point geometry.
options	{Object}

destroy

destroy: function()

onWheelEvent

onWheelEvent: function( e )

Catch the wheel event and handle it xbrowserly

Parameters

{Event}

wheelZoom

wheelZoom: function( e )

Given the wheel event, we carry out the appropriate zooming in or out, based on the ‘wheelDelta’ or ‘detail’ property of the event.

Parameters

{Event}

mousemove

mousemove: function ( evt )

Update the stored mousePosition on every move.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

activate

activate: function ( evt )

deactivate

deactivate: function ( evt )

OpenLayers. Layer

Summary

Properties
opacity	{Float} The layer’s opacity.
Constants
EVENT_TYPES	{Array(String)} Supported application event types.
Properties
alpha	{Boolean} The layer’s images have an alpha channel.
inRange	{Boolean} The current map resolution is within the layer’s min/max range.
imageOffset	{OpenLayers.Pixel} For layers with a gutter, the image offset represents displacement due to the gutter.
options	{Object} An optional object whose properties will be set on the layer.
SUPPORTED_TRANSITIONS	{Array} An immutable (that means don’t change it!)
Functions
OpenLayers. Layer
destroy	Destroy is a destructor: this is to alleviate cyclic references which the Javascript garbage cleaner can not take care of on its own.
clone
moveTo
setMap	Set the map property for the layer.
afterAdd	Called at the end of the map.addLayer sequence.
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.
getDataExtent	Calculates the max extent which includes all of the data for the layer.
getZIndex	{Integer} the z-index of this layer
setZIndex
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.

Properties

opacity

{Float} The layer’s opacity. Float number between 0.0 and 1.0.

Constants

EVENT_TYPES

{Array(String)} Supported application event types. Register a listener for a particular event with the following syntax:

layer.events.register(type, obj, listener);

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.
loadend	Triggered when layer loading ends.
loadcancel	Triggered when layer loading is canceled.
visibilitychanged	Triggered when layer visibility is changed.
move	Triggered when layer moves (triggered with every mousemove during a drag).
moveend	Triggered when layer is done moving, object passed as argument has a zoomChanged boolean property which tells that the zoom has changed.

Properties

alpha

{Boolean} The layer’s images have an alpha channel. Default is false.

inRange

{Boolean} The current map resolution is within the layer’s min/max range. This is set in <OpenLayers.Map.setCenter> whenever the zoom changes.

imageOffset

{OpenLayers.Pixel} For layers with a gutter, the image offset represents displacement due to the gutter.

options

{Object} 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.

SUPPORTED_TRANSITIONS

{Array} An immutable (that means don’t change it!) list of supported transitionEffect values.

Functions

OpenLayers. Layer

Parameters

name	{String} The layer name
options	{Object} Hashtable of extra options to tag onto the layer

destroy

destroy: function( setNewBaseLayer )

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.

clone

clone: function ( obj )

Parameters

obj	{OpenLayers.Layer} The layer to be cloned

Returns

{OpenLayers.Layer} An exact clone of this OpenLayers.Layer

moveTo

moveTo:function( bounds,
zoomChanged,
dragging )

Parameters

bound	{OpenLayers.Bounds}
zoomChanged	{Boolean} Tells when zoom has changed, as layers have to do some init work in that case.
dragging	{Boolean}

setMap

setMap: function( map )

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	{OpenLayers.Map}

afterAdd

afterAdd: function()

Called at the end of the map.addLayer sequence. At this point, the map will have a base layer. To be overridden by subclasses.

initResolutions

initResolutions: function()

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

getDataExtent

getDataExtent: function ()

Calculates the max extent which includes all of the data for the layer. This function is to be implemented by subclasses.

Returns

getZIndex

getZIndex: function ()

Returns

{Integer} the z-index of this layer

setZIndex

setZIndex: function ( zIndex )

Parameters

zIndex

{Integer}

adjustBounds

adjustBounds: function ( bounds )

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. Marker.Box

Inherits from

OpenLayers.Marker

Summary

Properties
bounds	{OpenLayers.Bounds}
div	{DOMElement}
Functions
OpenLayers. Marker.Box
destroy
setBorder	Allow the user to change the box’s color and border width
draw
onScreen	{Boolean} Whether or not the marker is currently visible on screen.
display	Hide or show the icon

Properties

bounds

{OpenLayers.Handler.Drag}

div

{DOMElement}

Functions

OpenLayers. Marker.Box

Parameters

bounds	{OpenLayers.Bounds}
borderColor	{String}
borderWidth	{int}

destroy

destroy: function()

setBorder

setBorder: function ( color,
width )

Allow the user to change the box’s color and border width

Parameters

color	{String} Default is “red”
width	{int} Default is 2

draw

draw: function( px,
sz )

Parameters

px	{OpenLayers.Pixel}
sz	{OpenLayers.Size}

Returns

{DOMElement} A new DOM Image with this marker�s icon set at the location passed-in

onScreen

onScreen:function()

Rreturn

{Boolean} Whether or not the marker is currently visible on screen.

display

display: function( display )

Hide or show the icon

Parameters

display

{Boolean}

OpenLayers. Request. XMLHttpRequest

Standard-compliant (W3C) cross-browser implementation of the XMLHttpRequest object. From http://code.google.com/p/xmlhttprequest/.

Summary

Functions
OpenLayers. nullHandler	@param {} request
parseXMLString	Parse XML into a doc structure

Functions

OpenLayers. nullHandler

OpenLayers.nullHandler = function( request )

@param {} request

parseXMLString

OpenLayers.parseXMLString = function( text )

Parse XML into a doc structure

Parameters

text

{String}

Returns

{?} Parsed AJAX Responsev

OpenLayers.Ajax

Summary

Functions
emptyFunction
getTransport	{Object} Transport mechanism for whichever browser we’re in, or false if none available.
Properties
activeRequestCount	{Integer}

Functions

emptyFunction

emptyFunction: function ()

getTransport

getTransport: function()

Returns

{Object} Transport mechanism for whichever browser we’re in, or false if none available.

Properties

activeRequestCount

{Integer}

OpenLayers. Ajax. Responders

{Object}

Summary

Properties
responders	{Array}
Functions
register
unregister
dispatch
onCreate
onComplete

Properties

responders

{Array}

Functions

register

register: function( responderToAdd )

Parameters

responderToAdd

{?}

unregister

unregister: function( responderToRemove )

Parameters

responderToRemove

{?}

dispatch

dispatch: function( callback,
request,
transport )

Parameters

callback	{?}
request	{?}
transport	{?}

onCreate

onCreate: function()

onComplete

onComplete: function()

OpenLayers. Ajax.Base

Summary

Functions
OpenLayers. Ajax.Base

Functions

OpenLayers. Ajax.Base

Parameters

options

{Object}

OpenLayers. Ajax. Request

Deprecated. Use OpenLayers.Request method instead.

Inherit

OpenLayers.Ajax.Base

Summary

Properties
_complete	{Boolean}
Functions
OpenLayers. Ajax. Request
request
onStateChange
setRequestHeaders
success	{Boolean} -
getStatus
respondToReadyState
getHeader
dispatchException	If the optional onException function is set, execute it and then dispatch the call to any other listener registered for onException.
Properties
Events	{Array(String)}

Properties

_complete

{Boolean}

Functions

OpenLayers. Ajax. Request

Parameters

url	{String}
options	{Object}

request

request: function( url )

Parameters

url

{String}

onStateChange

onStateChange: function()

setRequestHeaders

setRequestHeaders: function()

success

success: function()

Returns

{Boolean} -

getStatus

getStatus: function()

Returns

{Integer}

Status

respondToReadyState

respondToReadyState: function( readyState )

Parameters

readyState

{?}

getHeader

getHeader: function( name )

Parameters

name	{String} Header name

Returns

{?}	response header for the given name

dispatchException

dispatchException: function( exception )

If the optional onException function is set, execute it and then dispatch the call to any other listener registered for onException.

If no optional onException function is set, we suspect that the user may have also not used OpenLayers.Ajax.Responders.register to register a listener for the onException call. To make sure that something gets done with this exception, only dispatch the call if there are listeners.

If you explicitly want to swallow exceptions, set request.options.onException to an empty function (function(){}) or register an empty function with OpenLayers.Ajax.Responders for onException.

Parameters

exception

{?}

Properties

Events

{Array(String)}

OpenLayers. Ajax. Response

Summary

Properties
status	{Integer}
statusText	{String}
Functions
OpenLayers. Ajax. Response
getStatus
getStatustext
getHeader
getResponseHeader
getElementsByTagNameNS
serializeXMLToString	Wrapper function around XMLSerializer, which doesn’t exist/work in IE/Safari.

Properties

status

{Integer}

statusText

{String}

Functions

OpenLayers. Ajax. Response

Parameters

request

{Object}

getStatus

getStatustext

Returns

{String}

statusText

getHeader

getResponseHeader

getResponseHeader: function( name )

Returns

{?}	response header for given name

getElementsByTagNameNS

OpenLayers.Ajax.getElementsByTagNameNS = function( parentnode,
nsuri,
nsprefix,
tagname )

Parameters

parentnode	{?}
nsuri	{?}
nsprefix	{?}
tagname	{?}

Returns

{?}

serializeXMLToString

OpenLayers.Ajax.serializeXMLToString = function( xmldom )

Wrapper function around XMLSerializer, which doesn’t exist/work in IE/Safari. We need to come up with a way to serialize in those browser: for now, these browsers will just fail. #535, #536

Parameters

xmldom {XMLNode} xml dom to serialize

Returns

{?}

OpenLayers. Control. DragPan

The DragPan control pans the map with a drag of the mouse.

Inherits from

OpenLayers.Control

Summary

Properties
type	{OpenLayers.Control.TYPES}
panned	{Boolean} The map moved.
interval	{Integer} The number of milliseconds that should ellapse before panning the map again.
Functions
draw	Creates a Drag handler, using panMap and panMapDone as callbacks.
panMap
panMapDone	Finish the panning operation.

Properties

type

{OpenLayers.Control.TYPES}

panned

{Boolean} The map moved.

interval

{Integer} The number of milliseconds that should ellapse before panning the map again. Set this to increase dragging performance. Defaults to 25 milliseconds.

Functions

draw

draw: function()

Creates a Drag handler, using panMap and panMapDone as callbacks.

panMap

panMap: function( xy )

Parameters

xy	{OpenLayers.Pixel} Pixel of the mouse position

panMapDone

panMapDone: function( xy )

Finish the panning operation. Only call setCenter (through panMap) if the map has actually been moved.

Parameters

xy	{OpenLayers.Pixel} Pixel of the mouse position

OpenLayers. Feature. Vector

Vector features use the OpenLayers.Geometry classes as geometry description. They have an ‘attributes’ property, which is the data object, and a ‘style’ property, the default values of which are defined in the OpenLayers.Feature.Vector.style objects.

Inherits from

OpenLayers.Feature

Summary

Properties
fid	{String}
bounds	{OpenLayers.Bounds} The box bounding that feature’s geometry, that property can be set by an OpenLayers.Format object when deserializing the feature, so in most cases it represents an information set by the server.
state	{String}
renderIntent	{String} rendering intent currently being used
Functions
OpenLayers. Feature. Vector	Create a vector feature.
destroy	nullify references to prevent circular references and memory leaks
clone	Create a clone of this vector feature.
onScreen	Determine whether the feature is within the map viewport.
createMarker
destroyMarker
createPopup
atPoint	Determins whether the feature intersects with the specified location.
destroyPopup
move	Moves the feature and redraws it at its new location
toState	Sets the new state
Constants
OpenLayers. Feature. Vector. style	OpenLayers features can have a number of style attributes.

Properties

fid

{String}

bounds

{OpenLayers.Bounds} The box bounding that feature’s geometry, that property can be set by an OpenLayers.Format object when deserializing the feature, so in most cases it represents an information set by the server.

state

{String}

renderIntent

{String} rendering intent currently being used

Functions

OpenLayers. Feature. Vector

Create a vector feature.

Parameters

geometry	{OpenLayers.Geometry} The geometry that this feature represents.
attributes	{Object} An optional object that will be mapped to the <attributes> property.
style	{Object} An optional style object.

destroy

destroy: function()

nullify references to prevent circular references and memory leaks

clone

clone: function ()

Create a clone of this vector feature. Does not set any non-standard properties.

Returns

{OpenLayers.Feature.Vector} An exact clone of this vector feature.

onScreen

onScreen:function( boundsOnly )

Determine whether the feature is within the map viewport. This method tests for an intersection between the geometry and the viewport bounds. If a more effecient but less precise geometry bounds intersection is desired, call the method with the boundsOnly parameter true.

Parameters

boundsOnly

{Boolean} Only test whether a feature’s bounds intersects the viewport bounds. Default is false. If false, the feature’s geometry must intersect the viewport for onScreen to return true.

Returns

{Boolean} The feature is currently visible on screen (optionally based on its bounds if boundsOnly is true).

createMarker

createMarker: function()

HACK	we need to decide if all vector features should be able to create markers

Returns

{OpenLayers.Marker} For now just returns null

destroyMarker

destroyMarker: function()

HACK	we need to decide if all vector features should be able to delete markers

If user overrides the createMarker() function, s/he should be able to also specify an alternative function for destroying it

createPopup

createPopup: function()

HACK	we need to decide if all vector features should be able to create popups

Returns

{OpenLayers.Popup} For now just returns null

atPoint

atPoint: function( lonlat,
toleranceLon,
toleranceLat )

Determins whether the feature intersects with the specified location.

Parameters

lonlat	{OpenLayers.LonLat}
toleranceLon	{float} Optional tolerance in Geometric Coords
toleranceLat	{float} Optional tolerance in Geographic Coords

Returns

{Boolean} Whether or not the feature is at the specified location

destroyPopup

destroyPopup: function()

HACK	we need to decide if all vector features should be able to delete popups

move

move: function( location )

Moves the feature and redraws it at its new location

Parameters

state

{OpenLayers.LonLat or OpenLayers.Pixel} the location to which to move the feature.

toState

toState: function( state )

Sets the new state

Parameters

state

{String}

Constants

OpenLayers. Feature. Vector. style

OpenLayers features can have a number of style attributes. The ‘default’ style will typically be used if no other style is specified. These styles correspond for the most part, to the styling properties defined by the SVG standard. Information on fill properties: http://www.w3.org- /TR- /SVG- /painting.html#FillProperties Information on stroke properties: http://www.w3.org- /TR- /SVG- /painting.html#StrokeProperties

Symbolizer properties

fill	{Boolean} Set to false if no fill is desired.
fillColor	{String} Hex fill color. Default is “#ee9900”.
fillOpacity	{Number} Fill opacity (0-1). Default is 0.4
stroke	{Boolean} Set to false if no stroke is desired.
strokeColor	{String} Hex stroke color. Default is “#ee9900”.
strokeOpacity	{Number} Stroke opacity (0-1). Default is 1.
strokeWidth	{Number} Pixel stroke width. Default is 1.
strokeLinecap	{String} Stroke cap type. Default is “round”. [butt \| round \| square]
strokeDashstyle	{String} Stroke dash style. Default is “solid”. [dot \| dash \| dashdot \| longdash \| longdashdot \| solid]
graphic	{Boolean} Set to false if no graphic is desired.
pointRadius	{Number} Pixel point radius. Default is 6.
pointerEvents	{String} Default is “visiblePainted”.
cursor	{String} Default is “”.
externalGraphic	{String} Url to an external graphic that will be used for rendering points.
graphicWidth	{Number} Pixel width for sizing an external graphic.
graphicHeight	{Number} Pixel height for sizing an external graphic.
graphicOpacity	{Number} Opacity (0-1) for an external graphic.
graphicXOffset	{Number} Pixel offset along the positive x axis for displacing an external graphic.
graphicYOffset	{Number} Pixel offset along the positive y axis for displacing an external graphic.
graphicZIndex	{Number} The integer z-index value to use in rendering.
graphicName	{String} Named graphic to use when rendering points. Supported values include “circle” (default), “square”, “star”, “x”, “cross”, “triangle”.
graphicTitle	{String} Tooltip for an external graphic. Only supported in Firefox and Internet Explorer.
backgroundGraphic	{String} Url to a graphic to be used as the background under an externalGraphic.
backgroundGraphicZIndex	{Number} The integer z-index value to use in rendering the background graphic.
backgroundXOffset	{Number} The x offset (in pixels) for the background graphic.
backgroundYOffset	{Number} The y offset (in pixels) for the background graphic.
backgroundHeight	{Number} The height of the background graphic. If not provided, the graphicHeight will be used.
backgroundWidth	{Number} The width of the background width. If not provided, the graphicWidth will be used.
label	{String} The text for an optional label. For browsers that use the canvas renderer, this requires either fillText or mozDrawText to be available.
labelAlign	{String} Label alignment. This specifies the insertion point relative to the text. It is a string composed of two characters. The first character is for the horizontal alignment, the second for the vertical alignment. Valid values for horizontal alignment: “l”=left, “c”=center, “r”=right. Valid values for vertical alignment: “t”=top, “m”=middle, “b”=bottom. Example values: “lt”, “cm”, “rb”. The canvas renderer does not support vertical alignment, it will always use “b”.
fontColor	{String} The font color for the label, to be provided like CSS.
fontFamily	{String} The font family for the label, to be provided like in CSS.
fontSize	{String} The font size for the label, to be provided like in CSS.
fontWeight	{String} The font weight for the label, to be provided like in CSS.
display	{String} Symbolizers will have no effect if display is set to “none”. All other values have no effect.

OpenLayers. Handler.Box

Handler for dragging a rectangle across the map. Box is displayed on mouse down, moves on mouse move, and is finished on mouse up.

Inherits from

OpenLayers.Handler

Summary

Properties
dragHandler	{OpenLayers.Handler.Drag}
boxCharacteristics	{Object} Caches some box characteristics from css.
Functions
OpenLayers. Handler.Box
setMap
startBox
moveBox
endBox
removeBox	Remove the zoombox from the screen and nullify our reference to it.
activate
deactivate
getCharacteristics	Determines offset and box model for a box.

Properties

dragHandler

boxCharacteristics

{Object} Caches some box characteristics from css. This is used by the getBoxCharacteristics method.

Functions

OpenLayers. Handler.Box

Parameters

control	{OpenLayers.Control}
callbacks	{Object} An object containing a single function to be called when the drag operation is finished. The callback should expect to recieve a single argument, the point geometry.
options	{Object}

setMap

setMap: function ( map )

startBox

startBox: function ( xy )

Parameters

evt

{Event}

moveBox

moveBox: function ( xy )

endBox

endBox: function( end )

removeBox

removeBox: function()

Remove the zoombox from the screen and nullify our reference to it.

activate

activate: function ()

deactivate

deactivate: function ()

getCharacteristics

Determines offset and box model for a box.

Returns

{Object} a hash with the following properties:

xOffset - Corner offset in x-direction
yOffset - Corner offset in y-direction
newBoxModel - true for all browsers except IE in quirks mode

OpenLayers. Handler. RegularPolygon

Handler to draw a regular polygon on the map. Polygon is displayed on mouse down, moves or is modified on mouse move, and is finished on mouse up. The handler triggers callbacks for ‘done’ and ‘cancel’. Create a new instance with the OpenLayers.Handler.RegularPolygon constructor.

Inherits from

OpenLayers.Handler

Summary

Properties
angle	{Float} The angle from the origin (mouse down) to the current mouse position, in radians.
fixedRadius	{Boolean} The polygon has a fixed radius.
feature	{OpenLayers.Feature.Vector} The currently drawn polygon feature
layer	{OpenLayers.Layer.Vector} The temporary drawing layer
origin	{OpenLayers.Geometry.Point} Location of the first mouse down
Functions
OpenLayers. Handler. RegularPolygon	Create a new regular polygon handler.
down	Start drawing a new feature
move	Respond to drag move events
up	Finish drawing the feature
out	Finish drawing the feature.
createGeometry	Create the new polygon geometry.
modifyGeometry	Modify the polygon geometry in place.
calculateAngle	Calculate the angle based on settings.
finalize	Finish the geometry and call the “done” callback.
callback	Trigger the control’s named callback with the given arguments

Properties

angle

{Float} The angle from the origin (mouse down) to the current mouse position, in radians. This is measured counterclockwise from the positive x-axis.

fixedRadius

{Boolean} The polygon has a fixed radius. True if a radius is set before drawing begins. False otherwise.

feature

{OpenLayers.Feature.Vector} The currently drawn polygon feature

layer

{OpenLayers.Layer.Vector} The temporary drawing layer

origin

{OpenLayers.Geometry.Point} Location of the first mouse down

Functions

OpenLayers. Handler. RegularPolygon

Create a new regular polygon handler.

Parameters

control	{OpenLayers.Control} The control that owns this handler
callbacks	{Object} An object with a properties whose values are functions. Various callbacks described below.
options	{Object} An object with properties to be set on the handler. If the options.sides property is not specified, the number of sides will default to 4.

Named callbacks

create	Called when a sketch is first created. Callback called with the creation point geometry and sketch feature.
done	Called when the sketch drawing is finished. The callback will recieve a single argument, the sketch geometry.
cancel	Called when the handler is deactivated while drawing. The cancel callback will receive a geometry.

down

down: function( evt )

Start drawing a new feature

Parameters

evt	{Event} The drag start event

move

move: function( evt )

Respond to drag move events

Parameters

evt	{Evt} The move event

up

up: function( evt )

Finish drawing the feature

Parameters

evt	{Event} The mouse up event

out

out: function( evt )

Finish drawing the feature.

Parameters

evt	{Event} The mouse out event

createGeometry

createGeometry: function()

Create the new polygon geometry. This is called at the start of the drag and at any point during the drag if the number of sides changes.

modifyGeometry

modifyGeometry: function()

Modify the polygon geometry in place.

calculateAngle

calculateAngle: function( point,
evt )

Calculate the angle based on settings.

Parameters

point	{OpenLayers.Geometry.Point}
evt	{Event}

finalize

finalize: function()

Finish the geometry and call the “done” callback.

callback

callback: function ( name,
args )

Trigger the control’s named callback with the given arguments

Parameters

name	{String} The key for the callback that is one of the properties of the handler’s callbacks object.
args	{Array} An array of arguments with which to call the callback (defined by the control).

OpenLayers. Layer. EventPane

Base class for 3rd party layers. Create a new event pane layer with the OpenLayers.Layer.EventPane constructor.

Inherits from

OpenLayers.Layer

Summary

Properties
isBaseLayer	{Boolean} EventPaned layers are always base layers, by necessity.
pane	{DOMElement} A reference to the element that controls the events.
mapObject	{Object} This is the object which will be used to load the 3rd party library in the case of the google layer, this will be of type GMap, in the case of the ve layer, this will be of type VEMap
Functions
OpenLayers. Layer. EventPane	Create a new event pane layer
setMap	Set the map property for the layer.
loadWarningMessage	If we can’t load the map lib, then display an error message to the user and tell them where to go for help.
getWarningHTML	To be implemented by subclasses.
display	Set the display on the pane
setZIndex	Set the z-index order for the pane.
moveTo	Handle calls to move the layer.
getLonLatFromViewPortPx	Get a map location from a pixel location
getViewPortPxFromLonLat	Get a pixel location from a map location
getOLLonLatFromMapObjectLonLat	Get an OL style map location from a 3rd party style map location
getMapObjectLonLatFromOLLonLat	Get a 3rd party map location from an OL map location.
getOLPixelFromMapObjectPixel	Get an OL pixel location from a 3rd party pixel location.
getMapObjectPixelFromOLPixel	Get a 3rd party pixel location from an OL pixel location

Properties

isBaseLayer

{Boolean} EventPaned layers are always base layers, by necessity.

pane

{DOMElement} A reference to the element that controls the events.

mapObject

{Object} This is the object which will be used to load the 3rd party library in the case of the google layer, this will be of type GMap, in the case of the ve layer, this will be of type VEMap

Functions

OpenLayers. Layer. EventPane

Create a new event pane layer

Parameters

name	{String}
options	{Object} Hashtable of extra options to tag onto the layer

setMap

setMap: function( map )

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.

Parameters

map	{OpenLayers.Map}

loadWarningMessage

loadWarningMessage:function()

If we can’t load the map lib, then display an error message to the user and tell them where to go for help.

This function sets up the layout for the warning message. Each 3rd party layer must implement its own getWarningHTML() function to provide the actual warning message.

getWarningHTML

getWarningHTML:function()

To be implemented by subclasses.

Returns

{String} String with information on why layer is broken, how to get it working.

display

display: function( display )

Set the display on the pane

Parameters

display

{Boolean}

setZIndex

setZIndex: function ( zIndex )

Set the z-index order for the pane.

Parameters

zIndex

{int}

moveTo

moveTo:function( bounds,
zoomChanged,
dragging )

Handle calls to move the layer.

Parameters

bounds	{OpenLayers.Bounds}
zoomChanged	{Boolean}
dragging	{Boolean}

getLonLatFromViewPortPx

getLonLatFromViewPortPx: function ( viewPortPx )

Get a map location from a pixel location

Parameters

viewPortPx

Returns

{OpenLayers.LonLat} An OpenLayers.LonLat which is the passed-in view port OpenLayers.Pixel, translated into lon/lat by map lib If the map lib is not loaded or not centered, returns null

getViewPortPxFromLonLat

getViewPortPxFromLonLat: function ( lonlat )

Get a pixel location from a map location

Parameters

lonlat

Returns

{OpenLayers.Pixel} An OpenLayers.Pixel which is the passed-in OpenLayers.LonLat, translated into view port pixels by map lib If map lib is not loaded or not centered, returns null

getOLLonLatFromMapObjectLonLat

getOLLonLatFromMapObjectLonLat: function( moLonLat )

Get an OL style map location from a 3rd party style map location

Parameters moLonLat - {Object}

Returns

{OpenLayers.LonLat} An OpenLayers.LonLat, translated from the passed in MapObject LonLat Returns null if null value is passed in

getMapObjectLonLatFromOLLonLat

getMapObjectLonLatFromOLLonLat: function( olLonLat )

Get a 3rd party map location from an OL map location.

Parameters

olLonLat

Returns

{Object} A MapObject LonLat, translated from the passed in OpenLayers.LonLat Returns null if null value is passed in

getOLPixelFromMapObjectPixel

getOLPixelFromMapObjectPixel: function( moPixel )

Get an OL pixel location from a 3rd party pixel location.

Parameters

moPixel

{Object}

Returns

{OpenLayers.Pixel} An OpenLayers.Pixel, translated from the passed in MapObject Pixel Returns null if null value is passed in

getMapObjectPixelFromOLPixel

getMapObjectPixelFromOLPixel: function( olPixel )

Get a 3rd party pixel location from an OL pixel location

Parameters

olPixel

{OpenLayers.Layer.Vector}

Returns

{Object} A MapObject Pixel, translated from the passed in OpenLayers.Pixel Returns null if null value is passed in

OpenLayers. Layer. FixedZoomLevels

Some Layers will already have established zoom levels (like google or ve). Instead of trying to determine them and populate a resolutions[] Array with those values, we will hijack the resolution functionality here.

When you subclass FixedZoomLevels

The initResolutions() call gets nullified, meaning no resolutions[] array is set up. Which would be a big problem getResolution() in Layer, since it merely takes map.zoom and indexes into resolutions[]... but....

The getResolution() call is also overridden. Instead of using the resolutions[] array, we simply calculate the current resolution based on the current extent and the current map size. But how will we be able to calculate the current extent without knowing the resolution...?

The getExtent() function is also overridden. Instead of calculating extent based on the center point and the current resolution, we instead calculate the extent by getting the lonlats at the top-left and bottom-right by using the getLonLatFromViewPortPx() translation function, taken from the pixel locations (0,0) and the size of the map. But how will we be able to do lonlat-px translation without resolution....?

The getZoomForResolution() method is overridden. Instead of indexing into the resolutions[] array, we call OpenLayers.Layer.getExent(), passing in the desired resolution. With this extent, we then call getZoomForExtent()

Whenever you implement a layer using OpenLayers.Layer.FixedZoomLevels, it is your responsibility to provide the following three functions:

getLonLatFromViewPortPx
getViewPortPxFromLonLat
getZoomForExtent

...those three functions should generally be provided by any reasonable API that you might be working from.

Summary

Functions
OpenLayers. Layer. FixedZoomLevels	Create a new fixed zoom levels layer.
initResolutions	Populate the resolutions array
getZoomForResolution	Get the zoom level for a given resolution
getOLZoomFromMapObjectZoom	Get the OL zoom index from the map object zoom level
getMapObjectZoomFromOLZoom	Get the map object zoom level from the OL zoom level

Functions

OpenLayers. Layer. FixedZoomLevels

Create a new fixed zoom levels layer.

initResolutions

initResolutions: function()

Populate the resolutions array

getZoomForResolution

getZoomForResolution: function( resolution )

Get the zoom level for a given resolution

Parameters

resolution

{Float}

Returns

{Integer} A suitable zoom level for the specified resolution. If no baselayer is set, returns null.

getOLZoomFromMapObjectZoom

getOLZoomFromMapObjectZoom: function( moZoom )

Get the OL zoom index from the map object zoom level

Parameters

moZoom

{Integer}

Returns

{Integer} An OpenLayers Zoom level, translated from the passed in zoom Returns null if null value is passed in

getMapObjectZoomFromOLZoom

getMapObjectZoomFromOLZoom: function( olZoom )

Get the map object zoom level from the OL zoom level

Parameters

olZoom

{Integer}

Returns

{Integer} A MapObject level, translated from the passed in olZoom Returns null if null value is passed in

OpenLayers. Layer. HTTPRequest

Inherits from

OpenLayers.Layer

Summary

Constants
URL_HASH_FACTOR	{Float} Used to hash URL param strings for multi-WMS server selection.
Properties
url	{Array(String) or String} This is either an array of url strings or a single url string.
params	{Object} Hashtable of key/value parameters
Functions
OpenLayers. Layer. HTTPRequest
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.
getFullRequestString	Combine url with layer’s params and these newParams.

Constants

URL_HASH_FACTOR

{Float} Used to hash URL param strings for multi-WMS server selection. Set to the Golden Ratio per Knuth’s recommendation.

Properties

url

{Array(String) or String} This is either an array of url strings or a single url string.

params

{Object} Hashtable of key/value parameters

Functions

OpenLayers. Layer. HTTPRequest

Parameters

name	{String}
url	{Array(String) or String}
params	{Object}
options	{Object} Hashtable of extra options to tag onto the layer

selectUrl

selectUrl: function( paramString,
urls )

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.

getFullRequestString

getFullRequestString:function( newParams,
altUrl )

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}

OpenLayers. Layer. Markers

Inherits from

OpenLayers.Layer

Summary

Properties
drawn	{Boolean} internal state of drawing.
Functions
OpenLayers. Layer. Markers	Create a Markers layer.
moveTo
clearMarkers	This method removes all markers from a layer.
drawMarker	Calculate the pixel location for the marker, create it, and add it to the layer’s div

Properties

drawn

{Boolean} internal state of drawing. This is a workaround for the fact that the map does not call moveTo with a zoomChanged when the map is first starting up. This lets us catch the case where we have never drawn the layer, and draw it even if the zoom hasn’t changed.

Functions

OpenLayers. Layer. Markers

Create a Markers layer.

Parameters

name	{String}
options	{Object} Hashtable of extra options to tag onto the layer

moveTo

moveTo:function( bounds,
zoomChanged,
dragging )

Parameters

bounds	{OpenLayers.Bounds}
zoomChanged	{Boolean}
dragging	{Boolean}

clearMarkers

clearMarkers: function()

This method removes all markers from a layer. The markers are not destroyed by this function, but are removed from the list of markers.

drawMarker

drawMarker: function( marker )

Calculate the pixel location for the marker, create it, and add it to the layer’s div

Parameters

marker

{OpenLayers.Marker}

OpenLayers. Layer. SphericalMercator

A mixin for layers that wraps up the pieces neccesary to have a coordinate conversion for working with commercial APIs which use a spherical mercator projection. Using this layer as a base layer, additional layers can be used as overlays if they are in the same projection.

A layer is given properties of this object by setting the sphericalMercator property to true.

More projection information

http://spatialreference.org- /ref- /user- /google-projection- /

Proj4 Text

+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs

WKT

900913=PROJCS[“WGS84 / Simple Mercator”, GEOGCS[“WGS 84”, DATUM[“WGS_1984”, SPHEROID[“WGS_1984”, 6378137.0, 298.257223563]], PRIMEM[“Greenwich”, 0.0], UNIT[“degree”, 0.017453292519943295], AXIS[“Longitude”, EAST], AXIS[“Latitude”, NORTH]], PROJECTION[“Mercator_1SP_Google”], PARAMETER[“latitude_of_origin”, 0.0], PARAMETER[“central_meridian”, 0.0], PARAMETER[“scale_factor”, 1.0], PARAMETER[“false_easting”, 0.0], PARAMETER[“false_northing”, 0.0], UNIT[“m”, 1.0], AXIS[“x”, EAST], AXIS[“y”, NORTH], AUTHORITY[“EPSG”,”900913”]]

Summary

Functions
getExtent	Get the map’s extent.
initMercatorParameters	Set up the mercator parameters on the layer: resolutions, projection, units.
projectForward	Given an object with x and y properties in EPSG:4326, modify the x,y properties on the object to be the Spherical Mercator projected coordinates.
projectInverse	Given an object with x and y properties in Spherical Mercator, modify the x,y properties on the object to be the unprojected coordinates.
Two transforms declared	Transforms from EPSG:4326 to EPSG:900913 and from EPSG:900913 to EPSG:4326 are set by this class.

Functions

getExtent

getExtent: function()

Get the map’s extent.

Returns

{OpenLayers.Bounds} The map extent.

initMercatorParameters

initMercatorParameters: function()

Set up the mercator parameters on the layer: resolutions, projection, units.

projectForward

projectForward: function( point )

Given an object with x and y properties in EPSG:4326, modify the x,y properties on the object to be the Spherical Mercator projected coordinates.

Parameters

point

{Object} An object with x and y properties.

Returns

{Object} The point, with the x and y properties transformed to spherical mercator.

projectInverse

projectInverse: function( point )

Given an object with x and y properties in Spherical Mercator, modify the x,y properties on the object to be the unprojected coordinates.

Parameters

point

{Object} An object with x and y properties.

Returns

{Object} The point, with the x and y properties transformed from spherical mercator to unprojected coordinates..

Two transforms declared

Transforms from EPSG:4326 to EPSG:900913 and from EPSG:900913 to EPSG:4326 are set by this class.

OpenLayers. Control. DrawFeature

The DrawFeature control draws point, line or polygon features on a vector layer when active.

Inherits from

OpenLayers.Control

Summary

Properties
layer	{OpenLayers.Layer.Vector}
callbacks	{Object} The functions that are sent to the handler for callback
Constants
EVENT_TYPES
Functions
OpenLayers. Control. DrawFeature
drawFeature

Properties

layer

callbacks

{Object} The functions that are sent to the handler for callback

Constants

EVENT_TYPES

Supported event types

featureadded

Triggered when a feature is added

Functions

OpenLayers. Control. DrawFeature

Parameters

layer	{OpenLayers.Layer.Vector}
handler	{OpenLayers.Handler}
options	{Object}

drawFeature

drawFeature: function( geometry )

OpenLayers. Control. Measure

Allows for drawing of features for measurements.

Inherits from

OpenLayers.Control

Summary

Constants
EVENT_TYPES	{Array(String)} Supported application event types.
Properties
callbacks	{Object} The functions that are sent to the handler for callback
displaySystem	{String} Display system for output measurements.
geodesic	{Boolean} Calculate geodesic metrics instead of planar metrics.
displaySystemUnits	{Object} Units for various measurement systems.
delay	{Number} Number of milliseconds between clicks before the event is considered a double-click.
delayedTrigger	{Number} Timeout id of trigger for measurepartial.
Functions
OpenLayers. Control. Measure
updateHandler
measureComplete	Called when the measurement sketch is done.
measurePartial	Called each time a new point is added to the measurement sketch.
measure
getBestArea	Based on the displaySystem returns the area of a geometry.
getArea
getBestLength	Based on the displaySystem returns the length of a geometry.
getLength

Constants

EVENT_TYPES

{Array(String)} Supported application event types. Register a listener for a particular event with the following syntax:

control.events.register(type, obj, listener);

Listeners will be called with a reference to an event object. The properties of this event depends on exactly what happened.

Supported control event types (in addition to those from OpenLayers.Control)

measure	Triggered when a measurement sketch is complete. Listeners will receive an event with measure, units, order, and geometry properties.
measurepartial	Triggered when a new point is added to the measurement sketch. Listeners receive an event with measure, units, order, and geometry.

Properties

callbacks

{Object} The functions that are sent to the handler for callback

displaySystem

{String} Display system for output measurements. Supported values are ‘english’, ‘metric’, and ‘geographic’. Default is ‘metric’.

geodesic

{Boolean} Calculate geodesic metrics instead of planar metrics. This requires that geometries can be transformed into Geographic/WGS84 (if that is not already the map projection). Default is false.

displaySystemUnits

{Object} Units for various measurement systems. Values are arrays of unit abbreviations (from OpenLayers.INCHES_PER_UNIT) in decreasing order of length.

delay

{Number} Number of milliseconds between clicks before the event is considered a double-click. The “measurepartial” event will not be triggered if the sketch is completed within this time. This is required for IE where creating a browser reflow (if a listener is modifying the DOM by displaying the measurement values) messes with the dblclick listener in the sketch handler.

delayedTrigger

{Number} Timeout id of trigger for measurepartial.

Functions

OpenLayers. Control. Measure

Parameters

handler	{OpenLayers.Handler}
options	{Object}

updateHandler

updateHandler: function( handler,
options )

Parameters

handler	{Function} One of the sketch handler constructors.
options	{Object} Options for the handler.

measureComplete

measureComplete: function( geometry )

Called when the measurement sketch is done.

Parameters

geometry

measurePartial

measurePartial: function( point,
geometry )

Called each time a new point is added to the measurement sketch.

Parameters

point	{OpenLayers.Geometry.Point} The last point added.
geometry	{OpenLayers.Geometry} The sketch geometry.

measure

measure: function( geometry,
eventType )

Parameters

geometry	{OpenLayers.Geometry}
eventType	{String}

getBestArea

getBestArea: function( geometry )

Based on the displaySystem returns the area of a geometry.

Parameters

geometry

Returns

{Array([Float, String])} Returns a two item array containing the area and the units abbreviation.

getArea

getArea: function( geometry,
units )

Parameters

geometry	{OpenLayers.Geometry}
units	{String} Unit abbreviation

Returns

{Float} The geometry area in the given units.

getBestLength

getBestLength: function( geometry )

Based on the displaySystem returns the length of a geometry.

Parameters

geometry

Returns

{Array([Float, String])} Returns a two item array containing the length and the units abbreviation.

getLength

getLength: function( geometry,
units )

Parameters

geometry	{OpenLayers.Geometry}
units	{String} Unit abbreviation

Returns

{Float} The geometry length in the given units.

OpenLayers. Control. ZoomBox

The ZoomBox control enables zooming directly to a given extent, by drawing a box on the map. The box is drawn by holding down shift, whilst dragging the mouse.

Inherits from

OpenLayers.Control

Summary

Properties
type	{OpenLayers.Control.TYPE}
out	{Boolean} Should the control be used for zooming out?
alwaysZoom	{Boolean} Always zoom in/out, when box drawed
Functions
draw
zoomBox

Properties

type

{OpenLayers.Control.TYPE}

out

{Boolean} Should the control be used for zooming out?

alwaysZoom

{Boolean} Always zoom in/out, when box drawed

Functions

draw

draw: function()

zoomBox

zoomBox: function ( position )

Parameters

position

{OpenLayers.Bounds} or {OpenLayers.Pixel}

OpenLayers. Format.WKT

Class for reading and writing Well-Known Text. Create a new instance with the OpenLayers.Format.WKT constructor.

Inherits from

OpenLayers.Format

Summary

Functions
OpenLayers. Format.WKT	Create a new parser for WKT
read	Deserialize a WKT string and return a vector feature or an array of vector features.
write	Serialize a feature or array of features into a WKT string.

Functions

OpenLayers. Format.WKT

Create a new parser for WKT

Parameters

options

{Object} An optional object whose properties will be set on this instance

Returns

{OpenLayers.Format.WKT} A new WKT parser.

read

read: function( wkt )

Deserialize a WKT string and return a vector feature or an array of vector features. Supports WKT for POINT, MULTIPOINT, LINESTRING, MULTILINESTRING, POLYGON, MULTIPOLYGON, and GEOMETRYCOLLECTION.

Parameters

wkt	{String} A WKT string

Returns

{<OpenLayers.Feature.Vector>|Array} A feature or array of features for GEOMETRYCOLLECTION WKT.

write

write: function( features )

Serialize a feature or array of features into a WKT string.

Parameters

features

{<OpenLayers.Feature.Vector>|Array} A feature or array of features

Returns

{String} The WKT string representation of the input geometries

OpenLayers. Layer. Google

Summary

Constants
MIN_ZOOM_LEVEL	{Integer} 0
MAX_ZOOM_LEVEL	{Integer} 19
RESOLUTIONS	{Array(Float)} Hardcode these resolutions so that they are more closely tied with the standard wms projection
Properties
dragObject	{GDraggableObject} Since 2.93, Google has exposed the ability to get the maps GDraggableObject.
termsOfUse	{DOMElement} Div for Google’s copyright and terms of use link
poweredBy	{DOMElement} Div for Google’s powered by logo and link
Functions
OpenLayers. Layer. Google
loadMapObject	Load the GMap and register appropriate event listeners.
setMapType	The map has been centered, and a map type was specified, so we set the map type on the gmap object, then unregister the listener so that we dont keep doing this every time the map moves.
display	Hide or show the layer
addContainerPxFunction	Hack-on function because GMAPS does not give it to us

Constants

MIN_ZOOM_LEVEL

{Integer} 0

MAX_ZOOM_LEVEL

{Integer} 19

RESOLUTIONS

{Array(Float)} Hardcode these resolutions so that they are more closely tied with the standard wms projection

Properties

dragObject

{GDraggableObject} Since 2.93, Google has exposed the ability to get the maps GDraggableObject. We can now use this for smooth panning

termsOfUse

{DOMElement} Div for Google’s copyright and terms of use link

poweredBy

{DOMElement} Div for Google’s powered by logo and link

Functions

OpenLayers. Layer. Google

Parameters

name	{String} A name for the layer.
options	{Object} An optional object whose properties will be set on the layer.

loadMapObject

loadMapObject:function()

Load the GMap and register appropriate event listeners. If we can’t load GMap2, then display a warning message.

setMapType

setMapType: function()

The map has been centered, and a map type was specified, so we set the map type on the gmap object, then unregister the listener so that we dont keep doing this every time the map moves.

display

display: function( display )

Hide or show the layer

Parameters

display

{Boolean}

addContainerPxFunction

addContainerPxFunction: function()

Hack-on function because GMAPS does not give it to us

Parameters

gLatLng

{GLatLng}

Returns

{GPoint} A GPoint specifying gLatLng translated into “Container” coords

OpenLayers. Layer.Grid

Base class for layers that use a lattice of tiles. Create a new grid layer with the OpenLayers.Layer.Grid constructor.

Inherits from

OpenLayers.Layer.HTTPRequest

Summary

Properties
grid	{Array(Array(OpenLayers.Tile))} This is an array of rows, each row is an array of tiles.
Functions
OpenLayers. Layer.Grid	Create a new grid layer
clearGrid	Go through and remove all tiles from the grid, calling destroy() on each of them to kill circular references
moveTo	This function is called whenever the map is moved.
getGridBounds	Deprecated.
initSingleTile
calculateGridLayout	Generate parameters for the grid layout.
initGriddedTiles
spiralTileLoad	Starts at the top right corner of the grid and proceeds in a spiral towards the center, adding tiles one at a time to the beginning of a queue.
addTileMonitoringHooks	This function takes a tile as input and adds the appropriate hooks to the tile so that the layer can keep track of the loading tiles.
removeTileMonitoringHooks	This function takes a tile as input and removes the tile hooks that were added in addTileMonitoringHooks()
moveGriddedTiles
shiftRow	Shifty grid work
shiftColumn	Shift grid work in the other dimension
removeExcessTiles	When the size of the map or the buffer changes, we may need to remove some excess rows and columns.
onMapResize	For singleTile layers, this will set a new tile size according to the dimensions of the map pane.

Properties

grid

{Array(Array(OpenLayers.Tile))} This is an array of rows, each row is an array of tiles.

Functions

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

clearGrid

clearGrid:function()

Go through and remove all tiles from the grid, calling destroy() on each of them to kill circular references

moveTo

moveTo:function( bounds,
zoomChanged,
dragging )

This function is called whenever the map is moved. All the moving of actual ‘tiles’ is done by the map, but moveTo’s role is to accept a bounds and make sure the data that that bounds requires is pre-loaded.

Parameters

bounds	{OpenLayers.Bounds}
zoomChanged	{Boolean}
dragging	{Boolean}

getGridBounds

getGridBounds: function()

Deprecated. This function will be removed in 3.0. Please use getTilesBounds() instead.

Returns

{OpenLayers.Bounds} A Bounds object representing the bounds of all the currently loaded tiles (including those partially or not at all seen onscreen)

initSingleTile

initSingleTile: function( bounds )

Parameters

bounds

calculateGridLayout

calculateGridLayout: function( bounds,
extent,
resolution )

Generate parameters for the grid layout. This

Parameters

bounds	{<OpenLayers.Bound>}
extent	{OpenLayers.Bounds}
resolution	{Number}

Returns

Object containing properties tilelon, tilelat, tileoffsetlat, tileoffsetlat, tileoffsetx, tileoffsety

initGriddedTiles

initGriddedTiles:function( bounds )

Parameters

bounds

spiralTileLoad

spiralTileLoad: function()

Starts at the top right corner of the grid and proceeds in a spiral towards the center, adding tiles one at a time to the beginning of a queue.

Once all the grid’s tiles have been added to the queue, we go back and iterate through the queue (thus reversing the spiral order from outside-in to inside-out), calling draw() on each tile.

addTileMonitoringHooks

addTileMonitoringHooks: function( tile )

This function takes a tile as input and adds the appropriate hooks to the tile so that the layer can keep track of the loading tiles.

Parameters

tile	{OpenLayers.Tile}

removeTileMonitoringHooks

removeTileMonitoringHooks: function( tile )

This function takes a tile as input and removes the tile hooks that were added in addTileMonitoringHooks()

Parameters

tile	{OpenLayers.Tile}

moveGriddedTiles

moveGriddedTiles: function( bounds )

Parameters

bounds

{OpenLayers.Control.DragPan}

shiftRow

shiftRow:function( prepend )

Shifty grid work

Parameters

prepend

{Boolean} if true, prepend to beginning. if false, then append to end

shiftColumn

shiftColumn: function( prepend )

Shift grid work in the other dimension

Parameters

prepend

{Boolean} if true, prepend to beginning. if false, then append to end

removeExcessTiles

removeExcessTiles: function( rows,
columns )

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.
colums	{Integer} Maximum number of columns we want our grid to have.

onMapResize

onMapResize: function()

For singleTile layers, this will set a new tile size according to the dimensions of the map pane.

OpenLayers. Layer. VirtualEarth

Inherits from

OpenLayers.Layer.EventPane
OpenLayers.Layer.FixedZoomLevels

Summary

Constants
MIN_ZOOM_LEVEL	{Integer} 1
MAX_ZOOM_LEVEL	{Integer} 17
RESOLUTIONS	{Array(Float)} Hardcode these resolutions so that they are more closely tied with the standard wms projection
Functions
OpenLayers. Layer. VirtualEarth
loadMapObject
onMapResize

Constants

MIN_ZOOM_LEVEL

{Integer} 1

MAX_ZOOM_LEVEL

{Integer} 17

RESOLUTIONS

{Array(Float)} Hardcode these resolutions so that they are more closely tied with the standard wms projection

Functions

OpenLayers. Layer. VirtualEarth

Parameters

name	{String}
options	{Object}

loadMapObject

loadMapObject:function()

onMapResize

onMapResize: function()

OpenLayers. Layer. Yahoo

Inherits from

OpenLayers.Layer.EventPane
OpenLayers.Layer.FixedZoomLevels

Summary

Constants
MIN_ZOOM_LEVEL	{Integer} 0
MAX_ZOOM_LEVEL	{Integer} 17
RESOLUTIONS	{Array(Float)} Hardcode these resolutions so that they are more closely tied with the standard wms projection
Functions
OpenLayers. Layer. Yahoo
loadMapObject
onMapResize
fixYahooEventPane	The map has been centered, so the mysterious yahoo eventpane has been added.

Constants

MIN_ZOOM_LEVEL

{Integer} 0

MAX_ZOOM_LEVEL

{Integer} 17

RESOLUTIONS

{Array(Float)} Hardcode these resolutions so that they are more closely tied with the standard wms projection

Functions

OpenLayers. Layer. Yahoo

Parameters

name	{String}
options	{Object}

loadMapObject

loadMapObject:function()

onMapResize

onMapResize: function()

fixYahooEventPane

fixYahooEventPane: function()

The map has been centered, so the mysterious yahoo eventpane has been added. we remove it so that it doesnt mess with our event pane.

OpenLayers. Protocol.HTTP

A basic HTTP protocol for vector layers. Create a new instance with the OpenLayers.Protocol.HTTP constructor.

Inherits from

OpenLayers.Protocol

Summary

Properties
url	{String} Service URL, read-only, set through the options passed to constructor.
headers	{Object} HTTP request headers, read-only, set through the options passed to the constructor, Example: {‘Content-Type’: ‘plain/text’}
params	{Object} Parameters of GET requests, read-only, set through the options passed to the constructor, Example: {‘bbox’: ‘5,5,5,5’}
callback	{Object} Function to be called when the <read>, <create>, <update>, <delete> or <commit> operation completes, read-only, set through the options passed to the constructor.
scope	{Object} Callback execution scope, read-only, set through the options passed to the constructor.
readWithPOST	{Boolean} true if read operations are done with POST requests instead of GET, defaults to false.
Functions
OpenLayers. Protocol.HTTP	A class for giving layers generic HTTP protocol.
createCallback	Returns a function that applies the given public method with resp and options arguments.
handleRead	Individual callbacks are created for read, create and update, should a subclass need to override each one separately.
handleCreate	Called the the request issued by <create> is complete.
handleUpdate	Called the the request issued by <update> is complete.
handleDelete	Called the the request issued by <delete> is complete.
handleResponse	Called by CRUD specific handlers.
parseFeatures	Read HTTP response body and return features.
callUserCallback	This method is used from within the commit method each time an an HTTP response is received from the server, it is responsible for calling the user-supplied callbacks.

Properties

url

{String} Service URL, read-only, set through the options passed to constructor.

headers

{Object} HTTP request headers, read-only, set through the options passed to the constructor, Example: {‘Content-Type’: ‘plain/text’}

params

{Object} Parameters of GET requests, read-only, set through the options passed to the constructor, Example: {‘bbox’: ‘5,5,5,5’}

callback

{Object} Function to be called when the <read>, <create>, <update>, <delete> or <commit> operation completes, read-only, set through the options passed to the constructor.

scope

{Object} Callback execution scope, read-only, set through the options passed to the constructor.

readWithPOST

{Boolean} true if read operations are done with POST requests instead of GET, defaults to false.

Functions

OpenLayers. Protocol.HTTP

A class for giving layers generic HTTP protocol.

Parameters

options

{Object} Optional object whose properties will be set on the instance.

Valid options include

url	{String}
headers	{Object}
params	{Object}
format	{OpenLayers.Format}
callback	{Function}
scope	{Object}

createCallback

createCallback: function( method,
response,
options )

Returns a function that applies the given public method with resp and options arguments.

Parameters

method	{Function} The method to be applied by the callback.
response	{OpenLayers.Protocol.Response} The protocol response object.
options	{Object} Options sent to the protocol method (read, create, update, or delete).

handleRead

handleRead: function( resp,
options )

Individual callbacks are created for read, create and update, should a subclass need to override each one separately.

Parameters

resp	{OpenLayers.Protocol.Response} The response object to pass to the user callback.
options	{Object} The user options passed to the read call.

handleCreate

handleCreate: function( resp,
options )

Called the the request issued by <create> is complete. May be overridden by subclasses.

Parameters

resp	{OpenLayers.Protocol.Response} The response object to pass to any user callback.
options	{Object} The user options passed to the create call.

handleUpdate

handleUpdate: function( resp,
options )

Called the the request issued by <update> is complete. May be overridden by subclasses.

Parameters

resp	{OpenLayers.Protocol.Response} The response object to pass to any user callback.
options	{Object} The user options passed to the update call.

handleDelete

handleDelete: function( resp,
options )

Called the the request issued by <delete> is complete. May be overridden by subclasses.

Parameters

resp	{OpenLayers.Protocol.Response} The response object to pass to any user callback.
options	{Object} The user options passed to the delete call.

handleResponse

handleResponse: function( resp,
options )

Called by CRUD specific handlers.

Parameters

resp	{OpenLayers.Protocol.Response} The response object to pass to any user callback.
options	{Object} The user options passed to the create, read, update, or delete call.

parseFeatures

parseFeatures: function( request )

Read HTTP response body and return features.

Parameters

request

{XMLHttpRequest} The request object

Returns

{Array({OpenLayers.Feature.Vector})} or {OpenLayers.Feature.Vector} Array of features or a single feature.

callUserCallback

callUserCallback: function( resp,
options )

This method is used from within the commit method each time an an HTTP response is received from the server, it is responsible for calling the user-supplied callbacks.

Parameters

resp	{OpenLayers.Protocol.Response}
options	{Object} The map of options passed to the commit call.

OpenLayers. Style

This class represents a UserStyle obtained from a SLD, containing styling rules.

Summary

Properties
title	{String} Title of this style (set if included in SLD)
description	{String} Description of this style (set if abstract is included in SLD)
rules	{Array(OpenLayers.Rule)}
context	{Object} An optional object with properties that symbolizers’ property values should be evaluated against.
defaultStyle	{Object} hash of style properties to use as default for merging rule-based style symbolizers onto.
defaultsPerSymbolizer	{Boolean} If set to true, the defaultStyle will extend the symbolizer of every rule.
propertyStyles	{Hash of Boolean} cache of style properties that need to be parsed for propertyNames.
Functions
OpenLayers. Style	Creates a UserStyle.
createSymbolizer	creates a style by applying all feature-dependent rules to the base style.
applySymbolizer
createLiterals	creates literals for all style properties that have an entry in <this.propertyStyles>.
findPropertyStyles	Looks into all rules for this style and the defaultStyle to collect all the style hash property names containing ${...}
addPropertyStyles
getSymbolizerPrefix	Returns the correct symbolizer prefix according to the geometry type of the passed geometry
createLiteral	converts a style value holding a combination of PropertyName and Literal into a Literal, taking the property values from the passed features.
Constants
OpenLayers. Style. SYMBOLIZER_PREFIXES	{Array} prefixes of the sld symbolizers.

Properties

title

{String} Title of this style (set if included in SLD)

description

{String} Description of this style (set if abstract is included in SLD)

rules

{Array(OpenLayers.Rule)}

context

{Object} An optional object with properties that symbolizers’ property values should be evaluated against. If no context is specified, feature.attributes will be used

defaultStyle

{Object} hash of style properties to use as default for merging rule-based style symbolizers onto. If no rules are defined, createSymbolizer will return this style. If defaultsPerSymbolizer is set to true, the defaultStyle will only be taken into account if there are rules defined.

defaultsPerSymbolizer

{Boolean} If set to true, the defaultStyle will extend the symbolizer of every rule. Properties of the defaultStyle will also be used to set missing symbolizer properties if the symbolizer has stroke, fill or graphic set to true. Default is false.

propertyStyles

{Hash of Boolean} cache of style properties that need to be parsed for propertyNames. Property names are keys, values won’t be used.

Functions

OpenLayers. Style

Creates a UserStyle.

Parameters

style	{Object} Optional hash of style properties that will be used as default style for this style object. This style applies if no rules are specified. Symbolizers defined in rules will extend this default style.
options	{Object} An optional object with properties to set on the style.

Valid options

rules

{Array(OpenLayers.Rule)} List of rules to be added to the style.

Return

{OpenLayers.Style}

createSymbolizer

createSymbolizer: function( feature )

creates a style by applying all feature-dependent rules to the base style.

Parameters

feature

{OpenLayers.Feature} feature to evaluate rules for

Returns

{Object} symbolizer hash

applySymbolizer

applySymbolizer: function( rule,
style,
feature )

Parameters

rule	{OpenLayers.Rule}
style	{Object}
feature	{<OpenLayer.Feature.Vector>}

Returns

{Object} A style with new symbolizer applied.

createLiterals

createLiterals: function( style,
feature )

creates literals for all style properties that have an entry in <this.propertyStyles>.

Parameters

style	{Object} style to create literals for. Will be modified inline.
feature	{Object}

Returns

{Object} the modified style

findPropertyStyles

findPropertyStyles: function()

Looks into all rules for this style and the defaultStyle to collect all the style hash property names containing ${...} strings that have to be replaced using the createLiteral method before returning them.

Returns

{Object} hash of property names that need createLiteral parsing. The name of the property is the key, and the value is true;

addPropertyStyles

addPropertyStyles: function( propertyStyles,
symbolizer )

Parameters

propertyStyles	{Object} hash to add new property styles to. Will be modified inline
symbolizer	{Object} search this symbolizer for property styles

Returns

{Object} propertyStyles hash

getSymbolizerPrefix

getSymbolizerPrefix: function( geometry )

Returns the correct symbolizer prefix according to the geometry type of the passed geometry

Parameters

geometry {OpenLayers.Geometry}

Returns

{String} key of the according symbolizer

createLiteral

OpenLayers.Style.createLiteral = function( value,
context,
feature )

converts a style value holding a combination of PropertyName and Literal into a Literal, taking the property values from the passed features.

Parameters

value	{String} value to parse. If this string contains a construct like “foo ${bar}”, then “foo “ will be taken as literal, and “${bar}” will be replaced by the value of the “bar” attribute of the passed feature.
context	{Object} context to take attribute values from
feature	{OpenLayers.Feature.Vector} The feature that will be passed to <OpenLayers.String.format> for evaluating functions in the context.

Returns

{String} the parsed value. In the example of the value parameter above, the result would be “foo valueOfBar”, assuming that the passed feature has an attribute named “bar” with the value “valueOfBar”.

Constants

OpenLayers. Style. SYMBOLIZER_PREFIXES

{Array} prefixes of the sld symbolizers. These are the same as the main geometry types

OpenLayers. Control. Navigation

The navigation control handles map browsing with mouse events (dragging, double-clicking, and scrolling the wheel). Create a new navigation control with the OpenLayers.Control.Navigation control.

Note that this control is added to the map by default (if no controls array is sent in the options object to the OpenLayers.Map constructor).

Inherits

OpenLayers.Control

Summary

Properties
dragPan	{OpenLayers.Control.DragPan}
zoomBox	{OpenLayers.Control.ZoomBox}
Functions
OpenLayers. Control. Navigation	Create a new navigation control
destroy	The destroy method is used to perform any clean up before the control is dereferenced.
activate
deactivate
draw
defaultDblClick
defaultDblRightClick
wheelChange
wheelUp	User spun scroll wheel up
wheelDown	User spun scroll wheel down
disableZoomWheel
enableZoomWheel

Properties

dragPan

zoomBox

{OpenLayers.Control.ZoomBox}

Functions

OpenLayers. Control. Navigation

Create a new navigation control

Parameters

options

{Object} An optional object whose properties will be set on the control

destroy

destroy: function()

The destroy method is used to perform any clean up before the control is dereferenced. Typically this is where event listeners are removed to prevent memory leaks.

activate

activate: function()

deactivate

deactivate: function()

draw

draw: function()

defaultDblClick

defaultDblClick: function ( evt )

Parameters

evt

{Event}

defaultDblRightClick

defaultDblRightClick: function ( evt )

Parameters

evt

{Event}

wheelChange

wheelChange: function( evt,
deltaZ )

Parameters

evt	{Event}
deltaZ	{Integer}

wheelUp

wheelUp: function( evt )

User spun scroll wheel up

Parameters

evt

{Event}

wheelDown

wheelDown: function( evt )

User spun scroll wheel down

Parameters

evt

{Event}

disableZoomWheel

disableZoomWheel : function()

enableZoomWheel

enableZoomWheel : function()

OpenLayers. Geometry

A Geometry is a description of a geographic object. Create an instance of this class with the OpenLayers.Geometry constructor. This is a base class, typical geometry types are described by subclasses of this class.

Summary

Properties
id	{String} A unique identifier for this geometry.
parent	{OpenLayers.Geometry}This is set when a Geometry is added as component of another geometry
bounds	{OpenLayers.Bounds} The bounds of this geometry
Functions
OpenLayers. Geometry	Creates a geometry object.
destroy	Destroy this geometry.
clearBounds	Nullify this components bounds and that of its parent as well.
extendBounds	Extend the existing bounds to include the new bounds.
atPoint
getLength	Calculate the length of this geometry.
getArea	Calculate the area of this geometry.
toString	Returns the Well-Known Text representation of a geometry
OpenLayers. Geometry. fromWKT	Generate a geometry given a Well-Known Text string.
OpenLayers. Geometry. segmentsIntersect	Determine whether two line segments intersect.
OpenLayers. Geometry. distanceToSegment

Properties

id

{String} A unique identifier for this geometry.

parent

{OpenLayers.Geometry}This is set when a Geometry is added as component of another geometry

bounds

{OpenLayers.Bounds} The bounds of this geometry

Functions

OpenLayers. Geometry

Creates a geometry object.

destroy

destroy: function()

Destroy this geometry.

clearBounds

clearBounds: function()

Nullify this components bounds and that of its parent as well.

extendBounds

extendBounds: function( newBounds )

Extend the existing bounds to include the new bounds. If geometry’s bounds is not yet set, then set a new Bounds.

Parameters

newBounds

atPoint

atPoint: function( lonlat,
toleranceLon,
toleranceLat )

Note	This is only an approximation based on the bounds of the geometry.

Parameters

lonlat	{OpenLayers.LonLat}
toleranceLon	{float} Optional tolerance in Geometric Coords
toleranceLat	{float} Optional tolerance in Geographic Coords

Returns

{Boolean} Whether or not the geometry is at the specified location

getLength

getLength: function()

Calculate the length of this geometry. This method is defined in subclasses.

Returns

{Float} The length of the collection by summing its parts

getArea

getArea: function()

Calculate the area of this geometry. This method is defined in subclasses.

Returns

{Float} The area of the collection by summing its parts

toString

toString: function()

Returns the Well-Known Text representation of a geometry

Returns

{String} Well-Known Text

OpenLayers. Geometry. fromWKT

OpenLayers.Geometry.fromWKT = function( wkt )

Generate a geometry given a Well-Known Text string.

Parameters

wkt	{String} A string representing the geometry in Well-Known Text.

Returns

{OpenLayers.Geometry} A geometry of the appropriate class.

OpenLayers. Geometry. segmentsIntersect

OpenLayers.Geometry.segmentsIntersect = function( seg1,
seg2,
options )

Determine whether two line segments intersect. Optionally calculates and returns the intersection point. This function is optimized for cases where seg1.x2 >= seg2.x1 || seg2.x2 >= seg1.x1. In those obvious cases where there is no intersection, the function should not be called.

Parameters

seg1	{Object} Object representing a segment with properties x1, y1, x2, and y2. The start point is represented by x1 and y1. The end point is represented by x2 and y2. Start and end are ordered so that x1 < x2.
seg2	{Object} Object representing a segment with properties x1, y1, x2, and y2. The start point is represented by x1 and y1. The end point is represented by x2 and y2. Start and end are ordered so that x1 < x2.
options	{Object} Optional properties for calculating the intersection.

Valid options

point

{Boolean} Return the intersection point. If false, the actual intersection point will not be calculated. If true and the segments intersect, the intersection point will be returned. If true and the segments do not intersect, false will be returned. If true and the segments are coincident, true will be returned.

tolerance

{Number} If a non-null value is provided, if the segments are within the tolerance distance, this will be considered an intersection. In addition, if the point option is true and the calculated intersection is within the tolerance distance of an end point, the endpoint will be returned instead of the calculated intersection. Further, if the intersection is within the tolerance of endpoints on both segments, or if two segment endpoints are within the tolerance distance of eachother (but no intersection is otherwise calculated), an endpoint on the first segment provided will be returned.

Returns

{Boolean | OpenLayers.Geometry.Point} The two segments intersect. If the point argument is true, the return will be the intersection point or false if none exists. If point is true and the segments are coincident, return will be true (and the instersection is equal to the shorter segment).

OpenLayers. Geometry. distanceToSegment

OpenLayers.Geometry.distanceToSegment = function( point,
segment )

Parameters

point	{Object} An object with x and y properties representing the point coordinates.
segment	{Object} An object with x1, y1, x2, and y2 properties representing endpoint coordinates.

Returns

{Object} An object with distance, x, and y properties. The distance will be the shortest distance between the input point and segment. The x and y properties represent the coordinates along the segment where the shortest distance meets the segment.

OpenLayers. Layer. MapGuide

Instances of OpenLayers.Layer.MapGuide are used to display data from a MapGuide OS instance.

Inherits from

OpenLayers.Layer.Grid

Summary

Constants
TILE_PARAMS	{Object} Hashtable of default parameter key/value pairs for tiled layer
SINGLE_TILE_PARAMS	{Object} Hashtable of default parameter key/value pairs for untiled layer
OVERLAY_PARAMS	{Object} Hashtable of default parameter key/value pairs for untiled layer
FOLDER_PARAMS	{Object} Hashtable of parameter key/value pairs which describe the folder structure for tiles as configured in the mapguide serverconfig.ini section [TileServiceProperties]
Properties
defaultSize	{OpenLayers.Size} Tile size as produced by MapGuide server
Functions
OpenLayers. Layer. MapGuide	Create a new Mapguide layer, either tiled or untiled.
MapGuide OS uses a DPI value and degrees to meters conversion	factor that are different than the defaults used in OpenLayers, so these must be adjusted accordingly in your application.
clone	Create a clone of this layer
addTile	Creates a tile, initializes it, and adds it to the layer div.
getURL	Return a query string for this layer
getFullRequestString	getFullRequestString on MapGuide layers is special, because we do a regular expression replace on ‘,’ in parameters to ‘+’.
getImageFilePath	special handler to request mapguide tiles from an http exposed tilecache
calculateGridLayout	Generate parameters for the grid layout.

Constants

TILE_PARAMS

{Object} Hashtable of default parameter key/value pairs for tiled layer

SINGLE_TILE_PARAMS

{Object} Hashtable of default parameter key/value pairs for untiled layer

OVERLAY_PARAMS

{Object} Hashtable of default parameter key/value pairs for untiled layer

FOLDER_PARAMS

{Object} Hashtable of parameter key/value pairs which describe the folder structure for tiles as configured in the mapguide serverconfig.ini section [TileServiceProperties]

Properties

defaultSize

{OpenLayers.Size} Tile size as produced by MapGuide server

Functions

OpenLayers. Layer. MapGuide

Create a new Mapguide layer, either tiled or untiled.

For tiled layers, the ‘groupName’ and ‘mapDefinition’ values must be specified as parameters in the constructor.

For untiled base layers, specify either combination of ‘mapName’ and ‘session’, or ‘mapDefinition’ and ‘locale’.

For older versions of MapGuide and overlay layers, set useAsyncOverlay to false and in this case mapName and session are required parameters for the constructor.

MapGuide OS uses a DPI value and degrees to meters conversion

factor that are different than the defaults used in OpenLayers, so these must be adjusted accordingly in your application. See the MapGuide example for how to set these values for MGOS.

Parameters

name	{String} Name of the layer displayed in the interface
url	{String} Location of the MapGuide mapagent executable (e.g. http://localhost:8008- /mapguide- /mapagent- /mapagent.fcgi)
params	{Object} hashtable of additional parameters to use. Some parameters may require additional code on the server. The ones that you may want to use are:

mapDefinition - {String} The MapGuide resource definition (e.g. Library://Samples/Gmap/Maps/gmapTiled.MapDefinition)
locale - Locale setting (for untiled overlays layers only)
mapName - {String} Name of the map as stored in the MapGuide session. (for untiled layers with a session parameter only)
session - { String} MapGuide session ID (for untiled overlays layers only)
basemaplayergroupname - {String} GroupName for tiled MapGuide layers only
format - Image format to be returned (for untiled overlay layers only)
showLayers - {String} A comma separated list of GUID’s for the layers to display eg: ‘cvc-xcv34,453-345-345sdf’.
hideLayers - {String} A comma separated list of GUID’s for the layers to hide eg: ‘cvc-xcv34,453-345-345sdf’.
showGroups - {String} A comma separated list of GUID’s for the groups to display eg: ‘cvc-xcv34,453-345-345sdf’.
hideGroups - {String} A comma separated list of GUID’s for the groups to hide eg: ‘cvc-xcv34,453-345-345sdf’
selectionXml - {String} A selection xml string Some server plumbing is required to read such a value.

options

{Ojbect} Hashtable of extra options to tag onto the layer; will vary depending if tiled or untiled maps are being requested

clone

clone: function ( obj )

Create a clone of this layer

Returns

{OpenLayers.Layer.MapGuide} An exact clone of this layer

addTile

addTile:function( bounds,
position )

Creates a tile, initializes it, and adds it to the layer div.

Parameters

bounds	{OpenLayers.Bounds}
position	{OpenLayers.Pixel}

Returns

{OpenLayers.Tile.Image} The added OpenLayers.Tile.Image

getURL

getURL: function ( bounds )

Return a query string for this layer

Parameters

bounds

{OpenLayers.Bounds} A bounds representing the bbox for the request

Returns

{String} A string with the layer’s url and parameters and also the passed-in bounds and appropriate tile size specified as parameters.

getFullRequestString

getFullRequestString:function( newParams,
altUrl )

getFullRequestString on MapGuide layers is special, because we do a regular expression replace on ‘,’ in parameters to ‘+’. This is why it is subclassed here.

Parameters

altUrl

{String} Alternative base URL to use.

Returns

{String} A string with the layer’s url appropriately encoded for MapGuide

getImageFilePath

getImageFilePath:function( newParams,
altUrl )

special handler to request mapguide tiles from an http exposed tilecache

Parameters

altUrl

{String} Alternative base URL to use.

Returns

{String} A string with the url for the tile image

calculateGridLayout

calculateGridLayout: function( bounds,
extent,
resolution )

Generate parameters for the grid layout. This

Parameters

bounds	{<OpenLayers.Bound>}
extent	{OpenLayers.Bounds}
resolution	{Number}

Returns

Object containing properties tilelon, tilelat, tileoffsetlat, tileoffsetlat, tileoffsetx, tileoffsety

OpenLayers. Layer. MapServer

Instances of OpenLayers.Layer.MapServer are used to display data from a MapServer CGI instance.

Inherits from

OpenLayers.Layer.Grid

Summary

Constants
DEFAULT_PARAMS	{Object} Hashtable of default parameter key/value pairs
Functions
OpenLayers. Layer. MapServer	Create a new MapServer layer object
clone	Create a clone of this layer
addTile	Creates a tile, initializes it, and adds it to the layer div.
getURL	Return a query string for this layer
getFullRequestString	combine the layer’s url with its params and these newParams.

Constants

DEFAULT_PARAMS

{Object} Hashtable of default parameter key/value pairs

Functions

OpenLayers. Layer. MapServer

Create a new MapServer layer object

Parameters

name	{String} A name for the layer
url	{String} Base url for the MapServer CGI (e.g. http://www2.dmsolutions.ca/cgi-bin/mapserv)
params	{Object} An object with key/value pairs representing the GetMap query string parameters and parameter values.
options	{Ojbect} Hashtable of extra options to tag onto the layer

clone

clone: function ( obj )

Create a clone of this layer

Returns

{OpenLayers.Layer.MapServer} An exact clone of this layer

addTile

addTile:function( bounds,
position )

Creates a tile, initializes it, and adds it to the layer div.

Parameters

bounds	{OpenLayers.Bounds}
position	{OpenLayers.Pixel}

Returns

{OpenLayers.Tile.Image} The added OpenLayers.Tile.Image

getURL

getURL: function ( bounds )

Return a query string for this layer

Parameters

bounds

{OpenLayers.Bounds} A bounds representing the bbox for the request

Returns

{String} A string with the layer’s url and parameters and also the passed-in bounds and appropriate tile size specified as parameters.

getFullRequestString

getFullRequestString:function( newParams,
altUrl )

combine the layer’s url with its params and these newParams.

Parameter

newParams	{Object} New parameters that should be added to the request string.
altUrl	{String} (optional) Replace the URL in the full request string with the provided URL.

Returns

{String} A string with the layer’s url and parameters embedded in it.

OpenLayers. Layer.WMS

Instances of OpenLayers.Layer.WMS are used to display data from OGC Web Mapping Services. Create a new WMS layer with the OpenLayers.Layer.WMS constructor.

Inherits from

OpenLayers.Layer.Grid

Summary

Constants
DEFAULT_PARAMS	{Object} Hashtable of default parameter key/value pairs
Properties
reproject	Deprecated.
Functions
OpenLayers. Layer.WMS	Create a new WMS layer object
destroy	Destroy this layer
clone	Create a clone of this layer
getURL	Return a GetMap query string for this layer
addTile	addTile creates a tile, initializes it, and adds it to the layer div.

Constants

DEFAULT_PARAMS

{Object} Hashtable of default parameter key/value pairs

Properties

reproject

Deprecated. See http://trac.openlayers.org/wiki/SphericalMercator for information on the replacement for this functionality. {Boolean} Try to reproject this layer if its coordinate reference system is different than that of the base layer. Default is true. Set this in the layer options. Should be set to false in most cases.

Functions

OpenLayers. Layer.WMS

Create a new WMS layer object

Example

var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic",
                                   "http://wms.jpl.nasa.gov/wms.cgi",
                                   {layers: "modis,global_mosaic"});

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	{Ojbect} Hashtable of extra options to tag onto the layer

destroy

destroy: function()

Destroy this layer

clone

clone: function ( obj )

Create a clone of this layer

Returns

{OpenLayers.Layer.WMS} An exact clone of this layer

getURL

getURL: function ( bounds )

Return a GetMap query string for this layer

Parameters

bounds

{OpenLayers.Bounds} A bounds representing the bbox for the request.

Returns

{String} A string with the layer’s url and parameters and also the passed-in bounds and appropriate tile size specified as parameters.

addTile

addTile:function( bounds,
position )

addTile creates a tile, initializes it, and adds it to the layer div.

Parameters

bounds	{OpenLayers.Bounds}
position	{OpenLayers.Pixel}

Returns

{OpenLayers.Tile.Image} The added OpenLayers.Tile.Image

OpenLayers.Rule

This class represents an SLD Rule, as being used for rule-based SLD styling.

Summary

Properties
id	{String} A unique id for this session.
title	{String} Title of this rule (set if included in SLD)
description	{String} Description of this rule (set if abstract is included in SLD)
context	{Object} An optional object with properties that the rule should be evaluated against.
filter	{<OpenLayers.Filter>} Optional filter for the rule.
elseFilter	{Boolean} Determines whether this rule is only to be applied only if no other rules match (ElseFilter according to the SLD specification).
symbolizer	{Object} Symbolizer or hash of symbolizers for this rule.
Functions
OpenLayers.Rule	Creates a Rule.
getContext	Gets the context for evaluating this rule

Properties

id

{String} A unique id for this session.

title

{String} Title of this rule (set if included in SLD)

description

{String} Description of this rule (set if abstract is included in SLD)

context

{Object} An optional object with properties that the rule should be evaluated against. If no context is specified, feature.attributes will be used.

filter

{<OpenLayers.Filter>} Optional filter for the rule.

elseFilter

{Boolean} Determines whether this rule is only to be applied only if no other rules match (ElseFilter according to the SLD specification). Default is false. For instances of OpenLayers.Rule, if elseFilter is false, the rule will always apply. For subclasses, the else property is ignored.

symbolizer

{Object} Symbolizer or hash of symbolizers for this rule. If hash of symbolizers, keys are one or more of [“Point”, “Line”, “Polygon”]. The latter if useful if it is required to style e.g. vertices of a line with a point symbolizer. Note, however, that this is not implemented yet in OpenLayers, but it is the way how symbolizers are defined in SLD.

Functions

OpenLayers.Rule

Creates a Rule.

Parameters

options

{Object} An optional object with properties to set on the rule

Returns

{OpenLayers.Rule}

getContext

getContext: function( feature )

Gets the context for evaluating this rule

Paramters

feature

{OpenLayers.Feature} feature to take the context from if none is specified.

OpenLayers. StyleMap

Summary

Properties
styles	Hash of {OpenLayers.Style}, keyed by names of well known rendering intents (e.g.
extendDefault	{Boolean} if true, every render intent will extend the symbolizers specified for the “default” intent at rendering time.
Functions
OpenLayers. StyleMap
destroy
createSymbolizer	Creates the symbolizer for a feature for a render intent.
addUniqueValueRules	Convenience method to create comparison rules for unique values of a property.

Properties

styles

Hash of {OpenLayers.Style}, keyed by names of well known rendering intents (e.g. “default”, “temporary”, “select”, “delete”).

extendDefault

{Boolean} if true, every render intent will extend the symbolizers specified for the “default” intent at rendering time. Otherwise, every rendering intent will be treated as a completely independent style.

Functions

OpenLayers. StyleMap

Parameters

style	{Object} Optional. Either a style hash, or a style object, or a hash of style objects (style hashes) keyed by rendering intent. If just one style hash or style object is passed, this will be used for all known render intents (default, select, temporary)
options	{Object} optional hash of additional options for this instance

destroy

destroy: function()

createSymbolizer

createSymbolizer: function( feature,
intent )

Creates the symbolizer for a feature for a render intent.

Parameters

feature	{OpenLayers.Feature} The feature to evaluate the rules of the intended style against.
intent	{String} The intent determines the symbolizer that will be used to draw the feature. Well known intents are “default” (for just drawing the features), “select” (for selected features) and “temporary” (for drawing features).

Returns

{Object} symbolizer hash

addUniqueValueRules

addUniqueValueRules: function( renderIntent,
property,
symbolizers,
context )

Convenience method to create comparison rules for unique values of a property. The rules will be added to the style object for a specified rendering intent. This method is a shortcut for creating something like the “unique value legends” familiar from well known desktop GIS systems

Parameters

renderIntent	{String} rendering intent to add the rules to
property	{String} values of feature attributes to create the rules for
symbolizers	{Object} Hash of symbolizers, keyed by the desired property values
context	{Object} An optional object with properties that symbolizers’ property values should be evaluated against. If no context is specified, feature.attributes will be used

OpenLayers. Geometry. Collection

A Collection is exactly what it sounds like: A collection of different Geometries. These are stored in the local parameter <components> (which can be passed as a parameter to the constructor).

As new geometries are added to the collection, they are NOT cloned. When removing geometries, they need to be specified by reference (ie you have to pass in the exact geometry to be removed).

The getArea and getLength functions here merely iterate through the components, summing their respective areas and lengths.

Create a new instance with the OpenLayers.Geometry.Collection constructor.

Inerhits from

OpenLayers.Geometry

Summary

Properties
componentTypes	{Array(String)} An array of class names representing the types of components that the collection can include.
Functions
OpenLayers. Geometry. Collection	Creates a Geometry Collection -- a list of geoms.
getComponentsString	Get a string representing the components for this collection
addComponent	Add a new component (geometry) to the collection.
removeComponent	Remove a component from this geometry.

Properties

componentTypes

{Array(String)} An array of class names representing the types of components that the collection can include. A null value means the component types are not restricted.

Functions

OpenLayers. Geometry. Collection

Creates a Geometry Collection -- a list of geoms.

Parameters

components

{Array(OpenLayers.Geometry)} Optional array of geometries

getComponentsString

getComponentsString: function()

Get a string representing the components for this collection

Returns

{String} A string representation of the components of this geometry

addComponent

addComponent: function( component,
index )

Add a new component (geometry) to the collection. If this.componentTypes is set, then the component class name must be in the componentTypes array.

The bounds cache is reset.

Parameters

component	{OpenLayers.Geometry} A geometry to add
index	{int} Optional index into the array to insert the component

Returns

{Boolean} The component geometry was successfully added

removeComponent

removeComponent: function( component )

Remove a component from this geometry.

Parameters

component

OpenLayers. Geometry. Point

Point geometry class.

Inherits from

OpenLayers.Geometry

Summary

Functions
OpenLayers. Geometry. Point	Construct a point geometry.
calculateBounds	Create a new Bounds based on the lon/lat
toShortString	{String} Shortened String representation of Point object.

Functions

OpenLayers. Geometry. Point

Construct a point geometry.

Parameters

x	{float}
y	{float}

calculateBounds

calculateBounds: function ()

Create a new Bounds based on the lon/lat

toShortString

toShortString: function()

Returns

{String} Shortened String representation of Point object. (ex. ”5, 42”)

OpenLayers. Layer. Vector

Instances of OpenLayers.Layer.Vector are used to render vector data from a variety of sources. Create a new vector layer with the OpenLayers.Layer.Vector constructor.

Inherits from

OpenLayers.Layer

Summary

Constants
EVENT_TYPES	{Array(String)} Supported application event types.
Properties
selectedFeatures	{Array(OpenLayers.Feature.Vector)}
unrenderedFeatures	{Object} hash of features, keyed by feature.id, that the renderer failed to draw
styleMap	{OpenLayers.StyleMap}
strategies	{Array(OpenLayers.Strategy})} Optional list of strategies for the layer.
protocol	{OpenLayers.Protocol} Optional protocol for the layer.
renderers	{Array(String)} List of supported Renderer classes.
renderer	{OpenLayers.Renderer}
drawn	{Boolean} Whether the Vector Layer features have been drawn yet.
Functions
OpenLayers. Layer. Vector	Create a new vector layer
refresh	Ask the layer to request features again and redraw them.
assignRenderer	Iterates through the available renderer implementations and selects and assigns the first one whose “supported()” function returns true.
displayError	Let the user know their browser isn’t supported.
setMap	The layer has been added to the map.
afterAdd	Called at the end of the map.addLayer sequence.
removeMap	The layer has been removed from the map.
onMapResize	Notify the renderer of the change in size.
moveTo	Reset the vector layer’s div so that it once again is lined up with the map.
eraseFeatures	Erase features from the layer.
getFeatureFromEvent	Given an event, return a feature if the event occurred over one.

Constants

EVENT_TYPES

{Array(String)} Supported application event types. Register a listener for a particular event with the following syntax:

layer.events.register(type, obj, listener);

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 (in addition to those from OpenLayers.Layer)

beforefeatureadded	Triggered before a feature is added. Listeners will receive an object with a feature property referencing the feature to be added. To stop the feature from being added, a listener should return false.
beforefeaturesadded	Triggered before an array of features is added. Listeners will receive an object with a features property referencing the feature to be added. To stop the features from being added, a listener should return false.
featureadded	Triggered after a feature is added. The event object passed to listeners will have a feature property with a reference to the added feature.
featuresadded	Triggered after features are added. The event object passed to listeners will have a features property with a reference to an array of added features.
beforefeatureremoved	Triggered before a feature is removed. Listeners will receive an object with a feature property referencing the feature to be removed.
featureremoved	Triggerd after a feature is removed. The event object passed to listeners will have a feature property with a reference to the removed feature.
featuresremoved	Triggered after features are removed. The event object passed to listeners will have a features property with a reference to an array of removed features.
featureselected	Triggered after a feature is selected. Listeners will receive an object with a feature property referencing the selected feature.
featureunselected	Triggered after a feature is unselected. Listeners will receive an object with a feature property referencing the unselected feature.
beforefeaturemodified	Triggered when a feature is selected to be modified. Listeners will receive an object with a feature property referencing the selected feature.
featuremodified	Triggered when a feature has been modified. Listeners will receive an object with a feature property referencing the modified feature.
afterfeaturemodified	Triggered when a feature is finished being modified. Listeners will receive an object with a feature property referencing the modified feature.
vertexmodified	Triggered when a vertex within any feature geometry has been modified. Listeners will receive an object with a feature property referencing the modified feature, a vertex property referencing the vertex modified (always a point geometry), and a pixel property referencing the pixel location of the modification.
sketchstarted	Triggered when a feature sketch bound for this layer is started. Listeners will receive an object with a feature property referencing the new sketch feature and a vertex property referencing the creation point.
sketchmodified	Triggered when a feature sketch bound for this layer is modified. Listeners will receive an object with a vertex property referencing the modified vertex and a feature property referencing the sketch feature.
sketchcomplete	Triggered when a feature sketch bound for this layer is complete. Listeners will receive an object with a feature property referencing the sketch feature. By returning false, a listener can stop the sketch feature from being added to the layer.
refresh	Triggered when something wants a strategy to ask the protocol for a new set of features.

Properties

selectedFeatures

unrenderedFeatures

{Object} hash of features, keyed by feature.id, that the renderer failed to draw

styleMap

{OpenLayers.StyleMap}

strategies

{Array(OpenLayers.Strategy})} Optional list of strategies for the layer.

protocol

{OpenLayers.Protocol} Optional protocol for the layer.

renderers

{Array(String)} List of supported Renderer classes. Add to this list to add support for additional renderers. This list is ordered: the first renderer which returns true for the ‘supported()’ method will be used, if not defined in the ‘renderer’ option.

renderer

{OpenLayers.Renderer}

drawn

{Boolean} Whether the Vector Layer features have been drawn yet.

Functions

OpenLayers. Layer. Vector

Create a new vector layer

Parameters

name	{String} A name for the layer
options	{Object} Optional object with non-default properties to set on the layer.

Returns

{OpenLayers.Layer.Vector} A new vector layer

refresh

refresh: function( obj )

Ask the layer to request features again and redraw them. Triggers the refresh event if the layer is in range and visible.

Parameters

obj	{Object} Optional object with properties for any listener of the refresh event.

assignRenderer

assignRenderer: function()

Iterates through the available renderer implementations and selects and assigns the first one whose “supported()” function returns true.

displayError

displayError: function()

Let the user know their browser isn’t supported.

setMap

setMap: function( map )

The layer has been added to the map.

If there is no renderer set, the layer can’t be used. Remove it. Otherwise, give the renderer a reference to the map and set its size.

Parameters

map	{OpenLayers.Map}

afterAdd

afterAdd: function()

Called at the end of the map.addLayer sequence. At this point, the map will have a base layer. Any autoActivate strategies will be activated here.

removeMap

removeMap: function( map )

The layer has been removed from the map.

Parameters

map	{OpenLayers.Map}

onMapResize

onMapResize: function()

Notify the renderer of the change in size.

moveTo

moveTo: function( bounds,
zoomChanged,
dragging )

Reset the vector layer’s div so that it once again is lined up with the map. Notify the renderer of the change of extent, and in the case of a change of zoom level (resolution), have the renderer redraw features.

If the layer has not yet been drawn, cycle through the layer’s features and draw each one.

Parameters

bounds	{OpenLayers.Bounds}
zoomChanged	{Boolean}
dragging	{Boolean}

eraseFeatures

eraseFeatures: function( features )

Erase features from the layer.

Parameters

features

{OpenLayers.Geometry.MultiPoint}

getFeatureFromEvent

getFeatureFromEvent: function( evt )

Given an event, return a feature if the event occurred over one. Otherwise, return null.

Parameters

evt

{Event}

Returns

{OpenLayers.Feature.Vector} A feature if one was under the event.

OpenLayers. Geometry. MultiPoint

MultiPoint is a collection of Points. Create a new instance with the OpenLayers.Geometry.MultiPoint constructor.

Inherits from

OpenLayers.Geometry.Collection
OpenLayers.Geometry

Summary

Properties
componentTypes	{Array(String)} An array of class names representing the types of components that the collection can include.
Functions
OpenLayers. Geometry. MultiPoint	Create a new MultiPoint Geometry

Properties

componentTypes

{Array(String)} An array of class names representing the types of components that the collection can include. A null value means the component types are not restricted.

Functions

OpenLayers. Geometry. MultiPoint

Create a new MultiPoint Geometry

Parameters

components

{Array(OpenLayers.Geometry.Point)}

Returns

OpenLayers. Handler. Point

Handler to draw a point on the map. Point is displayed on mouse down, moves on mouse move, and is finished on mouse up. The handler triggers callbacks for ‘done’, ‘cancel’, and ‘modify’. The modify callback is called with each change in the sketch and will receive the latest point drawn. Create a new instance with the OpenLayers.Handler.Point constructor.

Inherits from

OpenLayers.Handler

Summary

Properties
point	{OpenLayers.Feature.Vector} The currently drawn point
layer	{OpenLayers.Layer.Vector} The temporary drawing layer
multi	{Boolean} Cast features to multi-part geometries before passing to the layer.
drawing	{Boolean} A point is being drawn
mouseDown	{Boolean} The mouse is down
lastDown	{OpenLayers.Pixel} Location of the last mouse down
lastUp	{OpenLayers.Pixel}
layerOptions	{Object} Any optional properties to be set on the sketch layer.
Functions
OpenLayers. Handler. Point	Create a new point handler.
createFeature	Add temporary features
destroyFeature	Destroy the temporary geometries
finalize	Finish the geometry and call the “done” callback.
click	Handle clicks.
dblclick	Handle double-clicks.
modifyFeature	Modify the existing geometry given a pixel location.
drawFeature	Render features on the temporary layer.
getGeometry	Return the sketch geometry.
geometryClone	Return a clone of the relevant geometry.
mousedown	Handle mouse down.
mousemove	Handle mouse move.
mouseup	Handle mouse up.

Properties

point

{OpenLayers.Feature.Vector} The currently drawn point

layer

{OpenLayers.Layer.Vector} The temporary drawing layer

multi

{Boolean} Cast features to multi-part geometries before passing to the layer. Default is false.

drawing

{Boolean} A point is being drawn

mouseDown

{Boolean} The mouse is down

lastDown

{OpenLayers.Pixel} Location of the last mouse down

lastUp

layerOptions

{Object} Any optional properties to be set on the sketch layer.

Functions

OpenLayers. Handler. Point

Create a new point handler.

Parameters

control	{OpenLayers.Control} The control that owns this handler
callbacks	{Object} An object with a properties whose values are functions. Various callbacks described below.
options	{Object} An optional object with properties to be set on the handler

Named callbacks

create	Called when a sketch is first created. Callback called with the creation point geometry and sketch feature.
modify	Called with each move of a vertex with the vertex (point) geometry and the sketch feature.
done	Called when the point drawing is finished. The callback will recieve a single argument, the point geometry.
cancel	Called when the handler is deactivated while drawing. The cancel callback will receive a geometry.

createFeature

createFeature: function( pixel )

Add temporary features

Parameters

pixel

{OpenLayers.Pixel} A pixel location on the map.

destroyFeature

destroyFeature: function()

Destroy the temporary geometries

finalize

finalize: function( cancel )

Finish the geometry and call the “done” callback.

Parameters

cancel

{Boolean} Call cancel instead of done callback. Default is false.

click

click: function( evt )

Handle clicks. Clicks are stopped from propagating to other listeners on map.events or other dom elements.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

dblclick

dblclick: function( evt )

Handle double-clicks. Double-clicks are stopped from propagating to other listeners on map.events or other dom elements.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

modifyFeature

modifyFeature: function( pixel )

Modify the existing geometry given a pixel location.

Parameters

pixel

{OpenLayers.Pixel} A pixel location on the map.

drawFeature

drawFeature: function()

Render features on the temporary layer.

getGeometry

getGeometry: function()

Return the sketch geometry. If multi is true, this will return a multi-part geometry.

Returns

geometryClone

geometryClone: function()

Return a clone of the relevant geometry.

Returns

mousedown

mousedown: function( evt )

Handle mouse down. Adjust the geometry and redraw. Return determines whether to propagate the event on the map.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

mousemove

mousemove: function ( evt )

Handle mouse move. Adjust the geometry and redraw. Return determines whether to propagate the event on the map.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

mouseup

mouseup: function ( evt )

Handle mouse up. Send the latest point in the geometry to the control. Return determines whether to propagate the event on the map.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

OpenLayers. Geometry. Curve

A Curve is a MultiPoint, whose points are assumed to be connected. To this end, we provide a “getLength()” function, which iterates through the points, summing the distances between them.

Inherits

OpenLayers.Geometry.MultiPoint

Summary

Properties
componentTypes	{Array(String)} An array of class names representing the types of components that the collection can include.
Functions
OpenLayers. Geometry. Curve

Properties

componentTypes

{Array(String)} An array of class names representing the types of components that the collection can include. A null value means the component types are not restricted.

Functions

OpenLayers. Geometry. Curve

Parameters

point

{Array(OpenLayers.Geometry.Point)}

OpenLayers. Geometry. LineString

A LineString is a Curve which, once two points have been added to it, can never be less than two points long.

Inherits from

OpenLayers.Geometry.Curve

Summary

Functions
OpenLayers. Geometry. LineString	Create a new LineString geometry
getSortedSegments	{Array} An array of segment objects.
splitWithSegment	Split this geometry with the given segment.
split	Use this geometry (the source) to attempt to split a target geometry.
splitWith	Split this geometry (the target) with the given geometry (the source).

Functions

OpenLayers. Geometry. LineString

Create a new LineString geometry

Parameters

points

{Array(OpenLayers.Geometry.Point)} An array of points used to generate the linestring

getSortedSegments

getSortedSegments: function()

Returns

{Array} An array of segment objects. Segment objects have properties x1, y1, x2, and y2. The start point is represented by x1 and y1. The end point is represented by x2 and y2. Start and end are ordered so that x1 < x2.

splitWithSegment

splitWithSegment: function( seg,
options )

Split this geometry with the given segment.

Parameters

seg	{Object} An object with x1, y1, x2, and y2 properties referencing segment endpoint coordinates.
options	{Object} Properties of this object will be used to determine how the split is conducted.

Valid options

edge	{Boolean} Allow splitting when only edges intersect. Default is true. If false, a vertex on the source segment must be within the tolerance distance of the intersection to be considered a split.
tolerance	{Number} If a non-null value is provided, intersections within the tolerance distance of one of the source segment’s endpoints will be assumed to occur at the endpoint.

Returns

{Object} An object with lines and points properties. If the given segment intersects this linestring, the lines array will reference geometries that result from the split. The points array will contain all intersection points. Intersection points are sorted along the segment (in order from x1,y1 to x2,y2).

split

split: function( target,
options )

Use this geometry (the source) to attempt to split a target geometry.

Parameters

target	{OpenLayers.Geometry} The target geometry.
options	{Object} Properties of this object will be used to determine how the split is conducted.

Valid options

mutual	{Boolean} Split the source geometry in addition to the target geometry. Default is false.
edge	{Boolean} Allow splitting when only edges intersect. Default is true. If false, a vertex on the source must be within the tolerance distance of the intersection to be considered a split.
tolerance	{Number} If a non-null value is provided, intersections within the tolerance distance of an existing vertex on the source will be assumed to occur at the vertex.

Returns

{Array} A list of geometries (of this same type as the target) that result from splitting the target with the source geometry. The source and target geometry will remain unmodified. If no split results, null will be returned. If mutual is true and a split results, return will be an array of two arrays - the first will be all geometries that result from splitting the source geometry and the second will be all geometries that result from splitting the target geometry.

splitWith

splitWith: function( geometry,
options )

Split this geometry (the target) with the given geometry (the source).

Parameters

geometry	{OpenLayers.Geometry} A geometry used to split this geometry (the source).
options	{Object} Properties of this object will be used to determine how the split is conducted.

Valid options

mutual	{Boolean} Split the source geometry in addition to the target geometry. Default is false.
edge	{Boolean} Allow splitting when only edges intersect. Default is true. If false, a vertex on the source must be within the tolerance distance of the intersection to be considered a split.
tolerance	{Number} If a non-null value is provided, intersections within the tolerance distance of an existing vertex on the source will be assumed to occur at the vertex.

Returns

OpenLayers. Geometry. LinearRing

A Linear Ring is a special LineString which is closed. It closes itself automatically on every addPoint/removePoint by adding a copy of the first point as the last point.

Also, as it is the first in the line family to close itself, a getArea() function is defined to calculate the enclosed area of the linearRing

Inherits

OpenLayers.Geometry.LineString

Summary

Properties
componentTypes	{Array(String)} An array of class names representing the types of components that the collection can include.
Functions
OpenLayers. Geometry. LinearRing	Linear rings are constructed with an array of points.
containsPoint	Test if a point is inside a linear ring.

Properties

componentTypes

{Array(String)} An array of class names representing the types of components that the collection can include. A null value means the component types are not restricted.

Functions

OpenLayers. Geometry. LinearRing

Linear rings are constructed with an array of points. This array can represent a closed or open ring. If the ring is open (the last point does not equal the first point), the constructor will close the ring. If the ring is already closed (the last point does equal the first point), it will be left closed.

Parameters

points

{Array(OpenLayers.Geometry.Point)} points

containsPoint

containsPoint: function( point )

Test if a point is inside a linear ring. For the case where a point is coincident with a linear ring edge, returns 1. Otherwise, returns boolean.

Parameters

point

{OpenLayers.Feature.Vector}

Returns

{Boolean | Number} The point is inside the linear ring. Returns 1 if the point is coincident with an edge. Returns boolean otherwise.

OpenLayers. Geometry. MultiLineString

A MultiLineString is a geometry with multiple OpenLayers.Geometry.LineString components.

Inherits from

OpenLayers.Geometry.Collection
OpenLayers.Geometry

Summary

Properties
componentTypes	{Array(String)} An array of class names representing the types of components that the collection can include.
Functions
OpenLayers. Geometry. MultiLineString	Constructor for a MultiLineString Geometry.
split	Use this geometry (the source) to attempt to split a target geometry.
splitWith	Split this geometry (the target) with the given geometry (the source).

Properties

componentTypes

{Array(String)} An array of class names representing the types of components that the collection can include. A null value means the component types are not restricted.

Functions

OpenLayers. Geometry. MultiLineString

Constructor for a MultiLineString Geometry.

Parameters

components

{Array(OpenLayers.Geometry.LineString)}

split

split: function( geometry,
options )

Use this geometry (the source) to attempt to split a target geometry.

Parameters

target	{OpenLayers.Geometry} The target geometry.
options	{Object} Properties of this object will be used to determine how the split is conducted.

Valid options

mutual	{Boolean} Split the source geometry in addition to the target geometry. Default is false.
edge	{Boolean} Allow splitting when only edges intersect. Default is true. If false, a vertex on the source must be within the tolerance distance of the intersection to be considered a split.
tolerance	{Number} If a non-null value is provided, intersections within the tolerance distance of an existing vertex on the source will be assumed to occur at the vertex.

Returns

splitWith

splitWith: function( geometry,
options )

Split this geometry (the target) with the given geometry (the source).

Parameters

geometry	{OpenLayers.Geometry} A geometry used to split this geometry (the source).
options	{Object} Properties of this object will be used to determine how the split is conducted.

Valid options

mutual	{Boolean} Split the source geometry in addition to the target geometry. Default is false.
edge	{Boolean} Allow splitting when only edges intersect. Default is true. If false, a vertex on the source must be within the tolerance distance of the intersection to be considered a split.
tolerance	{Number} If a non-null value is provided, intersections within the tolerance distance of an existing vertex on the source will be assumed to occur at the vertex.

Returns

OpenLayers. Handler.Path

Handler to draw a path on the map. Path is displayed on mouse down, moves on mouse move, and is finished on mouse up.

Inherits from

OpenLayers.Handler.Point

Summary

Properties
line	{OpenLayers.Feature.Vector}
freehand	{Boolean} In freehand mode, the handler starts the path on mouse down, adds a point for every mouse move, and finishes the path on mouse up.
freehandToggle	{String} If set, freehandToggle is checked on mouse events and will set the freehand mode to the opposite of this.freehand.
Functions
OpenLayers. Handler.Path	Create a new path hander
createFeature	Add temporary geometries
destroyFeature	Destroy temporary geometries
removePoint	Destroy the temporary point.
addPoint	Add point to geometry.
freehandMode	Determine whether to behave in freehand mode or not.
modifyFeature	Modify the existing geometry given the new point
drawFeature	Render geometries on the temporary layer.
getSketch	Return the sketch feature.
getGeometry	Return the sketch geometry.
mousedown	Handle mouse down.
mousemove	Handle mouse move.
mouseup	Handle mouse up.
dblclick	Handle double-clicks.

Properties

line

freehand

{Boolean} In freehand mode, the handler starts the path on mouse down, adds a point for every mouse move, and finishes the path on mouse up. Outside of freehand mode, a point is added to the path on every mouse click and double-click finishes the path.

freehandToggle

{String} If set, freehandToggle is checked on mouse events and will set the freehand mode to the opposite of this.freehand. To disallow toggling between freehand and non-freehand mode, set freehandToggle to null. Acceptable toggle values are ‘shiftKey’, ‘ctrlKey’, and ‘altKey’.

Functions

OpenLayers. Handler.Path

Create a new path hander

Parameters

control	{OpenLayers.Control} The control that owns this handler
callbacks	{Object} An object with a properties whose values are functions. Various callbacks described below.
options	{Object} An optional object with properties to be set on the handler

Named callbacks

create	Called when a sketch is first created. Callback called with the creation point geometry and sketch feature.
modify	Called with each move of a vertex with the vertex (point) geometry and the sketch feature.
point	Called as each point is added. Receives the new point geometry.
done	Called when the point drawing is finished. The callback will recieve a single argument, the linestring geometry.
cancel	Called when the handler is deactivated while drawing. The cancel callback will receive a geometry.

createFeature

createFeature: function( pixel )

Add temporary geometries

Parameters

pixel

{OpenLayers.Pixel} The initial pixel location for the new feature.

destroyFeature

destroyFeature: function()

Destroy temporary geometries

removePoint

removePoint: function()

Destroy the temporary point.

addPoint

addPoint: function( pixel )

Add point to geometry. Send the point index to override the behavior of LinearRing that disregards adding duplicate points.

Parameters

pixel

{OpenLayers.Pixel} The pixel location for the new point.

freehandMode

freehandMode: function( evt )

Determine whether to behave in freehand mode or not.

Returns

{Boolean}

modifyFeature

modifyFeature: function( pixel )

Modify the existing geometry given the new point

Parameters

pixel

{OpenLayers.Pixel} The updated pixel location for the latest point.

drawFeature

drawFeature: function()

Render geometries on the temporary layer.

getSketch

getSketch: function()

Return the sketch feature.

Returns

{OpenLayers.Feature.Vector}

getGeometry

getGeometry: function()

Return the sketch geometry. If <multi> is true, this will return a multi-part geometry.

Returns

{OpenLayers.Geometry.LineString}

mousedown

mousedown: function( evt )

Handle mouse down. Add a new point to the geometry and render it. Return determines whether to propagate the event on the map.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

mousemove

mousemove: function ( evt )

Handle mouse move. Adjust the geometry and redraw. Return determines whether to propagate the event on the map.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

mouseup

mouseup: function ( evt )

Handle mouse up. Send the latest point in the geometry to the control. Return determines whether to propagate the event on the map.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

dblclick

dblclick: function( evt )

Handle double-clicks. Finish the geometry and send it back to the control.

Parameters

evt	{Event} The browser event

Returns

{Boolean} Allow event propagation

OpenLayers. Geometry. Polygon

Polygon is a collection of Geometry.LinearRings.

Inherits from

OpenLayers.Geometry.Collection
OpenLayers.Geometry

Summary

Properties
componentTypes	{Array(String)} An array of class names representing the types of components that the collection can include.
Functions
OpenLayers. Geometry. Polygon	Constructor for a Polygon geometry.
containsPoint	Test if a point is inside a polygon.

Properties

componentTypes

{Array(String)} An array of class names representing the types of components that the collection can include. A null value means the component types are not restricted.

Functions

OpenLayers. Geometry. Polygon

Constructor for a Polygon geometry. The first ring (this.component[0])is the outer bounds of the polygon and all subsequent rings (this.component[1-n]) are internal holes.

Parameters

components

{Array(OpenLayers.Geometry.LinearRing)}

containsPoint

containsPoint: function( point )

Test if a point is inside a polygon. Points on a polygon edge are considered inside.

Parameters

point