Index
{int or OpenLayers.Bounds} An extra opportunity to specify internal padding of the content div inside the popup.
{OpenLayers.Bounds} Outside margin of the popup.
Display the page starting at the given index from the cache.
page: function( start, event )
Get the total count of pages given the current cache of features.
pageCount: function()
Gets or sets page length.
pageLength: function( newLength )
Display the next page of features.
pageNext: function( event )
Get the zero based page number.
pageNum: function()
Calculates the position of an element on the page
OpenLayers.Util.pagePosition = function( forElement )
Display the previous page of features.
pagePrevious: function()
{Boolean} The strategy is currently changing pages.
Create a new paging strategy.
Allows user to pan by a value of screen pixels
pan: function( dx, dy, options )
Control which handles the panning (in any of the cardinal directions) of the map by a set px distance.
{Integer} The number of steps to be passed to the OpenLayers.Tween.start() method when the map is panned.
{DOMElement} A reference to the element that controls the events.
Create a new control panel.
{Boolean} Set this property to false not to display the pan icons.
Pans the map such that the popup is totaly viewable (if necessary)
panIntoView: function()
panMap: function( xy )
Finish the panning operation.
panMapDone: function( xy )
{Boolean} When drawn, pan map such that the entire popup is visible in the current viewport (if necessary).
{Boolean} Framed Cloud does pan into view by default.
panMapStart: function()
{Function} The Easing function to be used for tweening.
{Boolean} The map moved.
Add the four directional pan buttons.
{Float} The ratio of the current extent within which panning will tween.
Allows user to pan to a new lonlat If the new lonlat is in the current extent the map will slide smoothly
panTo: function( lonlat )
{OpenLayers.Tween} Animated panning tween object, see panTo()
{String} Value of the csw:ParameterName element, used when writing a GetDomain document.
{Array(OpenLayers.Filter.Function || String || Number)} Function parameters For now support only other Functions, String or Number
{Object} Hashtable of key/value parameters
{Object} Extra parameters to include in tile requests.
{Object} Parameters of GET requests, read-only, set through the options passed to the constructor, Example: {‘bbox’: ‘5,5,5,5’}
{Object} Query string parameters to be appended to the URL.
{OpenLayers.Geometry}This is set when a Geometry is added as component of another geometry
Generate a date object from a string.
parse: function( str )
parseAttributes: function( node, type )
parseAttributes: function( node )
parseAttributes: function( node )
parseAttributes: function( node )
parseAttributes: function( node )
Object with properties corresponding to the GeoJSON geometry types.
Read data from a string, and return a list of features.
parseData: function( data, options )
Parse the data returned from the Events call.
parseData: function( ajaxRequest )
parseData: function( ajaxRequest )
Read HTTP response body and return records
parseData: function( request )
Parse the JSON from a request
parseData: function( str )
Parse the SLD WMS DescribeLayer response and issue the corresponding WFS DescribeFeatureType request
parseDescribeLayer: function( request )
Parse an array of coordinates into an ArcXML envelope structure.
parseEnvelope: function( env, arr )
Parse ExtendedData from KML.
parseExtendedData: function( node )
Parse feature from an Atom entry node..
parseFeature: function( node )
Convert a feature object from GeoJSON into an OpenLayers.Feature.Vector.
parseFeature: function( obj )
This function is the core of the GML parsing code in OpenLayers.
parseFeature: function( node )
This function is the core of the KML parsing code in OpenLayers.
parseFeature: function( node )
Return features from an Atom entry or feed.
parseFeatures: function( node )
Loop through all Placemark nodes and parse them.
parseFeatures: function( nodes, options )
Read HTTP response body and return features.
parseFeatures: function( request )
Read Script response body and return features.
parseFeatures: function( data )
Read HTTP response body and return features
parseFeatures: function( request )
Convert a geometry object from GeoJSON into an OpenLayers.Geometry.
parseGeometry: function( obj )
Properties of this object are the functions that parse geometries based on their type.
Properties of this object are the functions that parse geometries based on their type.
Parse the geometry and the feature bounds out of the node using Format.GML
parseGeometry: function( node )
Parses a kml color (in ‘aabbggrr’ format) and returns the corresponding color and opacity or null if the color is invalid.
parseKmlColor: function( kmlColor )
Finds URLs of linked KML documents and fetches them
parseLinks: function( nodes, options )
Parse the locations from an Atom entry or feed.
parseLocations: function( node )
Parse Atom person constructs from an Atom entry node.
parsePersonConstructs: function( node, name, data )
parsePointGeometry: function( node )
Convenience method to find a node and return its value
parseProperty: function( xmlNode, namespace, tagName )
{Object} Instance of the versioned parser.
Take an ArcXML response, and parse in into this object’s internal properties.
parseResponse: function( data )
Read HTTP response body and return features
parseResponse: function( request, options )
Parses the children of a Style node and builds the style hash accordingly
parseStyle: function( node )
Looks for Style nodes in the data and parses them Also parses StyleMap nodes, but only uses the ‘normal’ key
parseStyleMaps: function( nodes, options )
Looks for Style nodes in the data and parses them Also parses StyleMap nodes, but only uses the ‘normal’ key
parseStyles: function( nodes, options )
Parse XML into a doc structure
OpenLayers.parseXMLString = function( text )
Determine whether the event is within the optional double-cick pixel tolerance.
passesDblclickTolerance: function( evt )
Determine whether the event is within the optional pixel tolerance.
passesTolerance: function( evt )
Determine whether the mouse move is within the optional pixel tolerance.
passesTolerance: function( px )
Determine whether the event is within the optional pixel tolerance.
passesTolerance: function( pixel1, pixel2, tolerance )
This function is used to pass events that happen on the div, or the map, through to the slider, which then does its moving thing.
passEventToSlider:function( evt )
Create a new path hander
{Number} The number of pending requests.
{Boolean} The renderer needs a redraw call to render features added while the renderer was locked.
{Object} References all pending requests.
{Boolean}
{Boolean} Keep the temporary measurement sketch drawn after the measurement is complete.
{Boolean} Leave the feature rendered until destroyFeature is called.
{Boolean} Leave the feature rendered until clear is called.
Returns OpenLayers.Handler.Pinch
pinchDone: function( evt, start, last )
{Boolean}
pinchMove: function( evt, pinchData )
{Object} Cached object representing the pinch start (in pixels).
pinchStart: function( evt, pinchData )
{OpenLayers.Control.PinchZoom}
{OpenLayers.Control.PinchZoom}
Create a control for zooming with pinch gestures.
{Object} Options passed to the PinchZoom control.
{Object} Options passed to the PinchZoom control.
Create a new OpenLayers.Pixel instance
Takes a pixel as argument and creates bounds after adding the clickTolerance.
pixelToBounds: function( pixel )
{Number} Maximum number of pixels between mouseup and mousedown for an event to be considered a click.
{Number} Maximum number of pixels between down and up (mousedown and mouseup, or touchstart and touchend) for the handler to add a new point.
{String} Name of the placemarks.
Calls the appropriate easing method
play: function()
{Boolean} Tells if the easing is currently playing
{OpenLayers.Geometry.Point} The currently snapped vertex.
Return an array of coordinates from a point.
Convert a coordinate array from GeoJSON into an OpenLayers.Geometry.
Given an OpenLayers point geometry, create a GML point.
Given a GML node representing a point geometry, create an OpenLayers point geometry.
Given an OpenLayers point geometry, create a KML point.
Given a KML node representing a point geometry, create an OpenLayers point geometry.
{OpenLayers.Feature.Vector} The currently drawn point
Construct a point geometry.
Create a new point handler.
Create a symbolizer for rendering points.
Creates a new point grid layer.
{Number} Pixel point radius.
List of points use to calculate the kinetic initial values.
Constructor for a new OpenLayers.PointTrack instance.
Return an array of linear ring arrays from a polygon.
Convert a coordinate array from GeoJSON into an OpenLayers.Geometry.
Given an OpenLayers polygon geometry, create a GML polygon.
Given a GML node representing a polygon geometry, create an OpenLayers polygon geometry.
Given an OpenLayers polygon geometry, create a KML polygon.
Given a KML node representing a polygon geometry, create an OpenLayers polygon geometry.
{OpenLayers.Feature.Vector}
Constructor for a Polygon geometry.
Create a Polygon Handler.
Create a symbolizer for rendering polygons.
{OpenLayers.Popup}
Create a popup.
{OpenLayers.Class} The class which will be used to instantiate a new Popup.
{Array(OpenLayers.Popup)} List of popups associated with the map
{OpenLayers.Size} This determines the size of GeoRSS popups.
{OpenLayers.Pixel}
{OpenLayers.Pixel} Top Left pixel of the tile
{Object} Hash of different position blocks (Object/Hashs).
{Object} Hash of differen position blocks, keyed by relativePosition two-character code string (ie “tl”, “tr”, “bl”, “br”)
Using the properties currenty set on the layer, position the tile correctly.
positionTile: function()
Creates a new WMS layer object.
Send a POST request.
POST: function( config )
Things that have do be done after the geometry node is appended to its parent node.
postDraw: function( node )
postDraw: function( node )
{Boolean} Whether the filter (if there’s one) must be applied after the features have been read from the database; for example the BBOX strategy passes the read method a BBOX spatial filter, if postReadFiltering is true every feature read from the database will go through the BBOX spatial filter, which can be costly; defaults to true.
{DOMElement} Div for Google’s powered by logo and link
{Array} List representing precedence of different snapping types.
{Number} The number of significant digits to retain to avoid floating point precision errors.
method called before a feature is inserted.
preFeatureInsert: function( feature )
{String}
{Boolean} Load data before layer made visible.
{Boolean} set to true to not change the feature’s aspect ratio.
{Boolean} Serialize with extra whitespace for structure.
Used to prevent default events (especially opening images in a new tab on ctrl-click) from being executed for externalGraphic symbols
OpenLayers.Renderer.SVG.preventDefault = function( e )
Used to prevent default events (especially opening images in a new tab on ctrl-click) from being executed for externalGraphic and graphicName symbols
OpenLayers.Renderer.SVG2.preventDefault = function( e )
{OpenLayers.Control} A button type control whose trigger method restores the previous state managed by this control.
{Object} Set this property on the options argument of the constructor to set optional properties on the previous control.
{Array} List of items in the history.
Restore the previous state.
previousTrigger: function()
Recursive function to get back a flat list of layers from the hierarchic layer structure.
processLayer: function( layerArray, layer )
This function will be bound to an instance, linked to the global scope with an id, and called by the JSONP script returned by the API.
OpenLayers.Layer.Bing.processMetadata = function( metadata )
When passed an xmlNode, parses it for a GML point, and passes back an object describing that point.
processXMLNode: function( xmlNode )
Turns on the JavaScript profiler.
profile: function()
{String} If provided, use a custom profile.
{String} The specific profile
{String} If provided, use a custom profile.
{String} The specific profile
{String} If provided, use a custom profile.
Turns off the JavaScript profiler and prints its report.
profileEnd: function()
{Object} Proj4js.Proj instance.
{String}
{OpenLayers.Projection} or {String} Specifies the projection of the layer.
{OpenLayers.Projection} Source projection for the UTFGrids.
{String} Set in the map options to specify the default projection for layers added to this map.
This class offers several methods for interacting with a wrapped pro4js projection object.
{String} name of the context property to compare
{String} Name of the context property to compare.
{String} Value of the csw:PropertyName element, used when writing a GetDomain document.
{Hash of Boolean} cache of style properties that need to be parsed for propertyNames.
{OpenLayers.Protocol} Required.
{OpenLayers.Protocol} Optional protocol for the layer.
Abstract class for vector protocols.
Send an HTTP PUT request.
PUT: function( config )
{<OpenLayers.Pixel>|Object} An OpenLayers.Pixel or an object with a ‘x’ and ‘y’ properties.
OpenLayers
JavaScript Mapping Library