VEAltitudeMode = function()
{
/// ENUM: Defines the altitude of a point on the globe.
/// The altitude is meters above ground level.
/// The altitude is meters above the WGS 84 ellipsoid.
/// The altitude is meters above ground level.
};
VEAltitudeMode.Default = null;
VEAltitudeMode.Absolute = null;
VEAltitudeMode.RelativeToGround = null;
VEBirdseyeScene = function()
{
/// Contains the information about a specific bird's eye image.
}
VEBirdseyeScene.prototype =
{
ContainsLatLong: function(Latlong)
{
/// Determines whether the location specified by a VELatLong Class object is within the current VEBirdseyeScene object.
/// A VELatLong Class object. Required.
/// A Boolean value. True if the location specified by the VELatLong object is within the bounds of the VEBirdseyeScene object.
},
ContainsPixel: function(x, y, zoomLevel)
{
/// Determines whether a specified pixel is within the current VEBirdseyeScene object.
/// The X component of the pixel. Required.
/// The Y component of the pixel. Required.
/// A Boolean value. True if the specified pixel is within the bounds of the VEBirdseyeScene object.
},
GetBoundingRectangle: function()
{
/// Returns an unencrypted and rounded off bounding rectangle for the VEBirdseyeScene object.
/// A VELatLongRectangle Class object containing the bounding rectangle.
},
GetHeight: function()
{
/// Returns the height of the image in the current VEBirdseyeScene object, in pixels, at maximum resolution.
/// The height in pixels.
},
GetID: function()
{
/// Returns the ID of the current VEBirdseyeScene object.
/// The scene ID as an integer.
},
GetOrientation: function()
{
/// Returns the orientation (VEOrientation Enumeration) of the current VEBirdseyeScene object.
/// The VEOrientation Enumeration value.
},
GetThumbnailFilename: function()
{
/// Returns the file name of the thumbnail image associated with the current VEBirdseyeScene object.
/// The URL of the thumbnail image.
},
GetWidth: function()
{
/// Returns the width of the image in the current VEBirdseyeScene object, in pixels, at maximum resolution.
/// The width in pixels.
},
LatLongToPixel: function(LatLong, zoomLevel)
{
/// Converts a VELatLong Class object (latitude/longitude pair) to the corresponding pixel on the map.
/// A VELatLong Class object, which contains the latitude and longitude of a point. This method also accepts an encrypted VELatLong object, as supplied by the VEBirdseyeScene.PixelToLatLong Method.
/// The zoom level of the current map view
/// A pixel location of the VELatLong Class point. This object has two properties, x and y.
},
PixelToLatLong: function(pixel, zoomLevel)
{
/// Converts a point in the bird's eye scene to an encrypted latitude/longitude value.
/// A VEPixel Class object representing a pixel location on the map
/// The zoom level of the current map view
/// A String value that represents an encrypted VELatLong object.
}
}
VEClusteringOptions = function() {
/// Contains the options for customizing a pushpin cluster display.
/// A VECustomIconSpecification Class which describes the icon representing the pushpin cluster.
/// The name of the function called when clustering changes.
};
VEClusteringOptions.prototype = {
Icon: null,
Callback: null
};
VEClusteringType = function() {
/// ENUM: An enumeration of pushpin clustering algorithms.
/// No pushpin clustering
/// A simple clustering algorithm
};
VEClusteringType.None = null;
VEClusteringType.Grid = null;
VEClusterSpecification = function() {
/// Contains the shape objects and location of a pushpin cluster.
/// An array of VEShape Class items representing the pushpins in a pushpin cluster.
/// A VELatLong Class object indicating the center of the pushpin cluster.
};
VEClusterSpecification.prototype = {
Shapes: null,
LatLong: null,
GetClusterShape: function() {
/// Returns a VEShape Class that represents the pushpin cluster.
}
};
VEColor = function(r, g, b, a)
{
/// Initializes a new instance of the VEColor object.
/// The red component value. Valid values range from 0 through 255.
/// The green component value. Valid values range from 0 through 255.
/// The blue component value. Valid values range from 0 through 255.
/// The alpha (transparency) component value. Valid values range from 0.0 through 1.0.
/// Specifies the red component value. Valid values range from 0 through 255.
/// Specifies the green component value. Valid values range from 0 through 255.
/// Specifies the blue component value. Valid values range from 0 through 255.
/// Specifies the alpha (transparency) component value. Valid values range from 0.0 through 1.0.
}
VEColor.prototype =
{
R: null,
G: null,
B: null,
A: null
}
VECustomIconSpecification = function()
{
/// Initializes a new instance of the VECustomIconSpecification.
/// A VEColor object representing the icon's background and transparency.
/// Custom HTML representing the pin's appearance. 2D only.
/// A VEColor object representing the icon's text color and transparency.
/// A String representing the URL of an image file.
/// A VEPixel object representing the image's offset from the icon's anchor.
/// Specifies whether the text for the icon should be bold.
/// The actual text to display for the icon.
/// A String containing the name of the font to use for the icon text.
/// Specifies whether the text for the icon should be italic.
/// A VEPixel object representing the amount to offset text from the top left corner.
/// Specifies the size at which to display text, in points.
/// Specifies whether the text for the icon should be underlined.
};
VECustomIconSpecification.prototype =
{
BackColor: null,
CustomHTML: null,
ForeColor: null,
Image: null,
ImageOffset: null,
TextBold: null,
TextContent: null,
TextFont: null,
TextItalics: null,
TextOffset: null,
TextSize: null,
TextUnderline: null
}
VEDashboardSize = function()
{
/// ENUM: An enumeration that represents the size and type of dashboard to be displayed on the map.
/// This is the dashboard that is used by default.
/// This is a dashboard smaller than the default: it only contains zoom-out (+) and zoom-in (-) buttons and road, aerial, and hybrid buttons for changing the map style.
/// This is the smallest dashboard option available. This dashboard only contains zoom-out (+) and zoom-in (-) buttons.
};
VEDashboardSize.Normal = null;
VEDashboardSize.Small = null;
VEDashboardSize.Tiny = null;
VEDataType = function()
{
/// ENUM: An enumeration of shape layer data types.
/// This represents a GeoRSS data import.
/// This represents a Live Search Maps Collection (http://maps.live.com) import.
/// This represents a KML data import.
};
VEDataType.GeoRSS = null;
VEDataType.VECollection = null;
VEDataType.ImportXML = null;
VEDistanceUnit = function()
{
/// ENUM: An enumeration of the distance unit used for generating routes and itineraries.
/// Generates route information in miles.
/// Generates route information in kilometers.
};
VEDistanceUnit.Miles = null;
VEDistanceUnit.Kilometers = null;
VEException = function()
{
/// Contains the exception information for the map control.
/// A text description of the exception.
/// The name of the exception.
/// The source object that caused the exception.
};
VEException.prototype =
{
message: null,
name: null,
source: null
}
VEFailedShapeRequest = function()
{
/// ENUM: Defines a list of the actions on how to draw the polygons or the polylines whose points exceed the maximum limit or when a request to the server fails.
/// Do not draw the shape.
/// Draw the shape inaccurately.
/// Resubmit the drawing request.
};
VEFailedShapeRequest.DoNotDraw = null;
VEFailedShapeRequest.DrawInaccurately = null;
VEFailedShapeRequest.QueueRequest = null;
VEFindResult = function()
{
/// A single "what" result returned from a VEMap.Find Method search.
/// The description of the found result.
/// A Boolean value that indicates whether the found result is a paid advertisement.
/// A VELatLong Class object that represents the location of the found result.
/// The name of the found result.
/// The telephone number of the found result.
/// Gets or sets the VEFindType Enumeration that represents the type of Find that was performed.
/// A reference to the VEShape Class object corresponding to this FindResult object. The VEShape object represents the result's pushpin displayed on the map.
};
VEFindResult.prototype =
{
Description: null,
IsSponsored: null,
LatLong: null,
Name: null,
Phone: null,
FindType: null,
Shape: null
}
VEFindType = function()
{
/// ENUM: An enumeration of search types.
/// Performs a business search.
};
VEFindType.Businesses = null;
VEGeocodeLocation = function()
{
/// A location used to interpolate a found result for a location search.
/// A VELatLong Class object specifying the latitude and longitude of the location.
/// A VELocationPrecision Enumeration value specifying the precision of the location.
};
VEGeocodeLocation.prototype =
{
LatLong : null,
Precision : null
}
VEImageryMetadata = function() {
/// Contains information about the specified imagery.
/// A string specifying the start date of the date range when the imagery was created.
/// A string specifying the end date of the date range when the imagery was created.
};
VEImageryMetadata.prototype = {
DateRangeStart: null,
DateRangeEnd: null
};
VEImageryMetadataOptions = function() {
/// Contains the options that represent the imagery.
/// A VELatLong Class object specifying the center of the map view. Optionsl. Defaults to the center of the current map view.
/// A VEMapStyle Enumeration value specifying the map style. Optional. Defaults to the current map style.
/// An integer specifying the zoom level. Optional. Defaults to the current zoom level.
};
VEImageryMetadataOptions.prototype = {
LatLong: null,
MapStyle: null,
ZoomLevel: null
};
VELatLong = function(latitude, longitude, altitude, altitudeMode)
{
/// Initializes a new instance of the VELatLong Class.
/// The latitude of a single point on the globe.
/// The longitude of a single point on the globe.
/// The altitude of a single point on the globe.
/// A VEAltitudeMode Enumeration value representing the mode in which an altitude is represented.
/// Specifies the altitude of a single point on the globe.
/// Specifies the mode in which an altitude is represented.
/// Specifies the latitude of a single point on the globe.
/// Specifies the longitude of a single point on the globe.
}
VELatLong.prototype =
{
Altitude: null,
AltitudeMode: null,
Latitude: null,
Longitude: null,
SetAltitude: function(altitude, mode)
{
/// Initializes a new instance of the VELatLong Class.
/// The altitude of a single point on the globe.
/// A VEAltitudeMode Enumeration value representing the mode in which an altitude is represented.
}
}
VELatLongRectangle = function(TopLeftLatLong, BottomRightLatLong, TopRightLatLong, BottomLeftLatLong)
{
/// Initializes a new instance of the VELatLongRectangle object.
/// A VELatLong Class object that specifies the latitude and longitude of the upper-left corner of the map view.
/// A VELatLong Class object that specifies the latitude and longitude of the lower-right corner of the map view.
/// If the map is in 3D mode, a VELatLong Class object that specifies the latitude and longitude of the upper-right corner of the map view.
/// If the map is in 3D mode, a VELatLong Class object that specifies the latitude and longitude of the lower-left corner of the map view.
/// A VELatLong Class object that specifies the latitude and longitude of the upper-left corner of the map view.
/// A VELatLong Class object that specifies the latitude and longitude of the lower-right corner of the map view.
/// If the map is in 3D mode, a VELatLong Class object that specifies the latitude and longitude of the upper-right corner of the map view.
/// If the map is in 3D mode, a VELatLong Class object that specifies the latitude and longitude of the lower-left corner of the map view.
}
VELatLongRectangle.prototype =
{
TopLeftLatLong: null,
BottomRightLatLong: null,
TopRightLatLong: null,
BottomLeftLatLong: null
}
VELocationPrecision = function()
{
/// ENUM: An enumeration of location precision values.
/// The precision is estimated from multiple geocoded sources.
/// The precision is from a single match.
};
VELocationPrecision.Interpolated = null;
VELocationPrecision.Rooftop = null;
VEMap = function(control_id) {
/// Initializes a new instance of the VEMap class.
/// The ID of the HTML control that will contain the map.
/// Specifies the function to call when the map is first loaded.
}
VEMap.GetVersion = function() {
/// Returns the current version of the map control.
///
}
VEMap.prototype =
{
onLoadMap: null,
AddControl: function(element, zIndex) {
/// Adds a custom control to the map.
/// An HTML element that contains the control to be added.
/// The z-order for the control. Optional.
},
AddShape: function(shape) {
/// Adds a VEShape Class object or array of VEShape pushpin objects to the base layer.
/// The VEShape object or array of VEShape pushpin objects to be added. Required.
},
AddShapeLayer: function(Layer) {
/// Adds the specified shape layer to the map. If this layer reference already exists on the map, an exception is thrown, and no new layer is created.
/// A reference to the layer to add.
},
AddTileLayer: function(layerSource, visibleOnLoad) {
/// Adds a tile layer to the map, and if the visibleOnLoad parameter is true, it also shows it on the map.
/// The VETileSourceSpecification Class object representing the source of the tile layer. Required.
/// The VETileSourceSpecification Class object representing the source of the tile layer. Required.
},
AttachEvent: function(event, func) {
/// Attaches a Map Control event to a specified function.
/// The name of the Map Control event that generates the call.
/// The function to run when the event fires. It can be either the name of a function or the function itself.
},
Clear: function() {
/// Removes all shapes, shape layers, and search results on the map. Also removes the route from the map, if one is displayed. The Clear method does not remove custom tile layers from the map.
},
ClearInfoBoxStyles: function() {
/// Clears out all of the default Virtual Earth info box CSS styles.
},
ClearTraffic: function() {
/// Clears the traffic map.
},
DeleteAllShapeLayers: function() {
/// Deletes all shape layers, along with any shapes within the layers.
},
DeleteAllShapes: function() {
/// Deletes all shapes in all layers, leaving empty layers behind.
},
DeleteControl: function(element) {
/// Removes the specified control from the map.
/// An HTML element that contains the control to be deleted
},
DeleteRoute: function() {
/// Clears the current route (VERoute Class object) from the map.
},
DeleteShape: function(shape) {
/// Deletes a VEShape Class object from any layer, including the base map layer.
/// The reference to the VEShape object to be deleted. Required.
},
DeleteShapeLayer: function(layer) {
/// Deletes the specified shape layer from the map.
/// A reference to the layer to delete. Required.
},
DeleteTileLayer: function(layerID) {
/// Completely removes a tile layer from the map.
/// The ID of the layer to be deleted.
},
DetachEvent: function(event, func) {
/// Detaches the specified map control event so that it no longer calls the specified function.
/// The name of the map control event that generates the call.
/// The function that was specified to run when the event fired.
},
Dispose: function() {
/// Deletes the VEMap object and releases any associated resources.
},
EnableShapeDisplayThreshold: function(enable) {
/// Specifies whether shapes are drawn below a threshold zoom level.
/// A Boolean value specifying whether to draw shapes below a threshold zoom level. By default shapes are not drawn below a threshold zoom level.
},
EndContinuousPan: function() {
/// Stops the continuous map panning initiated by a call to the VEMap.StartContinuousPan Method.
},
Find: function(what, where, findType, shapeLayer, startIndex, numberOfResults, showResults, createResults, useDefaultDisambiguation, setBestMapView, callback) {
/// Performs a what (business) search and/or a where (location) search. At least one of these two parameters is required.
/// The business name, category, or other item searched for. This parameter must be supplied for a pushpin to be included in the results.
/// The address or place name of the area searched for. This parameter is overloaded; see the Remarks section for more information.
/// The VEFindType Enumeration that specifies the type of search performed. The only currently supported value is VEFindType.Businesses.
/// A reference to the VEShapeLayer Class object that contain the pins that result from this search if it is a "what" component. Optional. If the shape layer is not specified, the pins are added to the base map layer. If the reference is not a valid VEShapeLayer reference, an exception is thrown.
/// The beginning index of the results returned. Optional. Default is 0.
/// The number of results to be returned, starting at startIndex. The default is 10, the minimum is 1, and the maximum is 20.
/// A Boolean object that determines whether the resulting pushpins are visible. Optional. Default is true.
/// A Boolean true or false that determines whether pushpins are created when the what parameter is supplied. Optional. If set to the default true, pushpins are created. If set to false: The array of VEFindResult Class objects is still present in the callback, but no pushpin layer is created; The VEShapeLayer reference field within the callback is null; Each VEFindResult object's corresponding Shape property is null.
/// A Boolean true or false that determines whether the default disambiguation box appears when multiple location matches are possible. Optional. Default is true. If set to true, the default disambiguation box appears. If set to false the default disambiguation box is not displayed.
/// A Boolean true or false that determines whether the map view is moved to the first location match. If set to true, the map view is moved to the first location match. Default is true.
/// The name of the function to run when the search results are returned. If useDefaultDisambiguation is set to true, this callback will not be fired until the user has made a disambiguation choice. Optional.
},
FindLocations: function(veLatLong, callback) {
/// Performs a search for locations that match a VELatLong input.
/// A VELatLong Class object that specifies what map location to match.
/// The name of the function that the server calls when it returns search results.
},
GetAltitude: function() {
/// In 3D mode, returns a double that represents the altitude (in meters) above the geoid.
/// THIS VALUE NOT USED IN THE TOOLTIP:(
},
GetBirdseyeScene: function() {
/// If the map view is already set to bird's eye, returns the current VEBirdseyeScene Class object.
///
},
GetCenter: function() {
/// Returns a VELatLong Class object that represents the location of the center of the current map view.
///
},
GetDirections: function(locations, options) {
/// Draws a multi-point route on the map and sends details about the route to a callback function.
/// An array of objects specifying the points through which the route must pass. The points can be either VELatLong Class objects or String objects.
/// A VERouteOptions Class object specifying the routing options.
},
GetHeading: function() {
/// In 3D mode, returns a double that represents the compass heading of the current map view. Returns a double that represents the compass heading, where 0 is true north and 180 is true south.
///
},
GetImageryMetadata: function(callback, options) {
/// Returns information about the requested imagery, including imagery date stamps. This method requires that a valid token has been set using the VEMap.SetClientToken Method.
/// The name of the function to call when results are returned. The function must accept a VEImageryMetadata Class object. Required.
/// A VEImageryMetadataOptions class specifying the imagery for which information is returned. Optional.
///
},
GetLeft: function() {
/// Returns the pixel value of the left edge of the map control.
///
},
GetMapMode: function() {
/// Returns the current map mode as a VEMapMode Enumeration value.
///
},
GetMapStyle: function() {
/// Returns the current map style as a VEMapStyle Enumeration value that represents the current map style.
///
},
GetMapView: function() {
/// Returns the current map view object as a VELatLongRectangle Class object.
///
},
GetPitch: function() {
/// In 3D mode, returns a double that represents the pitch of the current map view. A double that represents the pitch, where 0 is level and -90 is straight down.
///
},
GetRoute: function(start, end, units, route_type, callback) {
/// This method is deprecated. Use the VEMap.GetDirections Method instead. Draws a route on the map and sends details about the route to a callback function.
/// The start location. This can be a string value of an address, a place name, or a VELatLong Class object that specifies the start location
/// The ending location. This can be a string value of an address, a place name, or a VELatLong object that specifies the end location
/// A VEDistanceUnit Enumeration value that specifies either miles or kilometers. Optional. Default is VEDistanceUnit.Miles
/// A VERouteType Enumeration value specifying either the shortest route or the quickest route. Optional. Default is VERouteType.Shortest
/// Specifies the function called after the route is drawn on the map. The callback function is passed a VERouteDeprecated Class object containing information about the route.
},
GetShapeByID: function(ID) {
/// Gets the reference to a VEShape Class object based on its internal identifier.
/// The identifier of the shape to retrieve. Required.
///
},
GetShapeLayerByIndex: function(index) {
/// Gets the reference to a VEShapeLayer Class object based on its index.
/// The index of the layer that you wish to retrieve. Required.
///
},
GetShapeLayerCount: function() {
/// Gets the total number of shape layers on the map.
///
},
GetTileLayerByID: function(id) {
/// Gets a tile layer based upon its identifier.
/// The unique identifier of the tile layer.
///
},
GetTileLayerByIndex: function(index) {
/// Gets a tile layer based upon its identifier.
/// The index into the list of tile layers. The value ranges from 0 to GetTileLayerCount.
///
},
GetTileLayerCount: function() {
/// Gets the number of tile layers.
///
},
GetTop: function() {
/// Returns the pixel value of the top edge of the map control.
///
},
GetZoomLevel: function() {
/// Returns the current zoom level of the map.
///
},
Hide3DNavigationControl: function() {
/// In 3D mode, hides the default user interface for controlling the map in 3D mode. By default, this control is shown.
},
HideAllShapeLayers: function() {
/// Hides all of the shape layers on the map.
},
HideControl: function(element) {
/// Hides the specified control from view.
/// An HTML element that contains the control to be hidden.
},
HideDashboard: function() {
/// Hides the default user interface for controlling the map (the compass and the zoom control).
},
HideFindControl: function() {
/// Removes the Find control from the map.
},
HideInfoBox: function() {
/// Hides a shape's custom or default info box. There can be only one info box on the screen at a given time. The method will hide the currently visible info box.
},
HideMiniMap: function() {
/// Hides the mini map from view.
},
HideScalebar: function() {
/// Hides the scale bar from the map.
},
HideTileLayer: function(layerID) {
/// Hides the specified control from view.
/// The ID of the layer to be hidden.
},
HideTrafficLegend: function() {
/// Hides the traffic legend.
},
ImportShapeLayerData: function(shapeSource, callback, setBestView) {
/// Imports data from a GeoRSS feed, Live Search Maps (http://maps.live.com) collection, or KML URL.
/// VEShapeSourceSpecification Class object specifying the imported shape data.
/// The function that is called after the data has been imported.
/// A Boolean value that specifies whether the map view is changed to the best view for the layer.
},
Import3DModel: function(modelShapeSource, callback, latlong, orientation, scale) {
/// Imports a model data file and displays a 3D model on the map.
/// A VEModelSourceSpecification Class object specifying the model data to import.
/// The name of the function that is called after the data has been imported. See below for the arguments received by the callback.
/// A VELatLong Class object that specifies the point at which to place the origin of the model.
/// A VEModelOrientation Class object that specifies the orientation of the model on the map.
/// A VEModelScale Class object that specifies the scale of the model.
},
IncludePointInView: function(latlong) {
/// Changes the map view so that it includes both the specified VELatLong Class point and the center point of the current map.
/// A VELatLong Class object that specifies the latitude and longitude of the point to include
},
IsBirdseyeAvailable: function() {
/// Determines whether the bird's eye map style is available in the current map view.
///
},
LatLongToPixel: function(LatLong) {
/// Converts a VELatLong Class object (latitude/longitude pair) to the corresponding pixel on the map.
/// A VELatLong Class object that contains the latitude and longitude of a point.
},
LoadMap: function(VELatLong, zoom, style, fixed, mode, showSwitch, tileBuffer, mapOptions) {
/// Loads the specified map. All parameters are optional.
/// A VELatLong Class object that represents the center of the map. Optional.
/// The zoom level to display. Valid values range from 1 through 19. Optional. Default is 4.
/// A VEMapStyle Enumeration value specifying the map style. Optional. Default is VEMapStyle.Road.
/// A Boolean value that specifies whether the map view is displayed as a fixed map that the user cannot change. Optional. Default is false.
/// A VEMapMode Enumeration value that specifies whether to load the map in 2D or 3D mode. Optional. Default is VEMapMode.Mode2D.
/// A Boolean value that specifies whether to show the map mode switch on the dashboard control. Optional. Default is true (the switch is displayed).
/// How much tile buffer to use when loading map. Default is 0 (do not load an extra boundary of tiles). This parameter is ignored in 3D mode.
/// A VEMapOptions Class that specifies other map options to set.
},
LoadTraffic: function(showFlow) {
/// Loads the traffic map. The traffic map is only available at zoom levels from 9 through 15, inclusively.
/// Whether to show the traffic flow.
},
Pan: function(deltaX, deltaY) {
/// When in 2D mode, moves the map the specified amount. The Pan method only applies to 2D mode maps. If you are working with maps in 3D mode, use the VEMap.StartContinuousPan Method and VEMap.EndContinuousPan Method.
/// The amount to move the map horizontally, in pixels
/// The amount to move the map vertically, in pixels
},
PanToLatLong: function(VELatLong) {
/// Pans the map to a specific latitude and longitude.
/// A VELatLong Class object that represents the latitude and longitude of the point on which to center the map
},
PixelToLatLong: function(pixel) {
/// Converts a pixel (a point on the map) to a VELatLong Class object (latitude/longitude pair).
/// VEPixel Class object representing a pixel location on the map.
///
},
Resize: function(width, height) {
/// Resizes the map based on the specified width and height. If this method is called with no parameters, the map is resized to fit the entire DIV element.
/// The width, in pixels, of the map. Optional.
/// The height, in pixels, of the map. Optional.
},
SetAltitude: function(altitude) {
/// In 3D mode, sets the altitude, in meters, above the WGS 84 ellipsoid in the map view.
/// The altitude, in meters.
},
SetBirdseyeOrientation: function(orientation) {
/// Changes the orientation of the existing bird's eye image (VEBirdseyeScene Class object) to the specified orientation.
///
},
SetBirdseyeScene: function(id) {
/// Displays the bird's eye image specified by the VEBirdseyeScene Class ID.
/// The ID of the VEBirdseyeScene Class object that you want to display
},
SetBirdseyeScene: function(veLatLong, orientation, zoomLevel, callback) {
/// Displays the bird's eye image specified by the center of the map, the orientation, and the zoom level
/// A VELatLong Class object specifying the center of the image. Optional. If this parameter is not supplied the center of the map is used.
/// A VEOrientation Enumeration value specifying the direction to which which the image is viewed. Optional. If this value is not supplied, the default value VEOrientation.North is used.
/// The level of zoom. Optional. If this parameter is not supplied, the value 1 is used.
/// The name of the function called when the SetBirdseyeScene method completes.
},
SetCenter: function(VELatLong) {
/// Centers the map to a specific latitude and longitude.
/// A VELatLong Class object that contains the latitude and longitude of the point on which to center the map.
},
SetCenterAndZoom: function(VELatLong, zoomLevel) {
/// Centers the map to a specific latitude and longitude and sets the zoom level.
/// A VELatLong Class object that contains the latitude and longitude of the point on which to center the map.
/// The zoom level for the map. Valid values range from 1 through 19.
},
SetClientToken: function(clientToken) {
/// Sets a Virtual Earth token for the VEMap object.
/// A string representing the Virtual Earth token.
},
SetDashboardSize: function(dashboardSize) {
/// Sets the map dashboard size and type. This method must be called before VEMap.LoadMap Method.
/// A VEDashboardSize Enumeration representing the dashboard size. Valid values are Normal, Small, and Tiny.
},
SetDefaultInfoBoxStyles: function() {
/// Sets the info box CSS styles back to their original classes.
},
SetFailedShapeRequest: function(policy) {
/// Specifies what the map control does when a request to the server to get the accurate position of a shape when the map style is changed to birdseye fails.
/// A VEFailedShapeRequest Enumeration value that defines the policy.
},
SetHeading: function(heading) {
/// In 3D mode, sets the compass heading of the current map view.
/// The compass direction, expressed as a double. A value of 0 is true north, and a value of 180 is true south. Values less than 0 and greater than 360 are valid and are calculated as compass directions.
},
SetMapMode: function(mode) {
/// Sets the mode of the map.
/// A VEMapMode Enumeration value that specifies whether to load the map in 2D or 3D mode.
},
SetMapStyle: function(mapStyle) {
/// Sets the style of the map.
/// A VEMapStyle Enumeration value specifying the map style.
},
SetMapView: function(object) {
/// Sets the map view to include all of the points, lines, or polygons specified in the provided array, or to the view defined by a VEMapViewSpecification Class object.
/// In 2D mode, an array of VELatLong Class points or a VELatLongRectangle Class object. In 3D mode, can also be a VEMapViewSpecification Class object. This object defines the location, altitude, pitch, and heading to use for the map view.
},
SetMouseWheelZoomToCenter: function(zoomToCenter) {
/// Specifies whether to zoom to the center of the screen or to the cursor position on the screen.
/// A Boolean value specifying whether to zoom to the center of the screen or to the cursor position. If true, the map control zooms to the center of the screen; if false, the map control zooms to the cursor position on the screen.
},
SetPitch: function(pitch) {
/// In 3D mode, sets the pitch of the current map view.
/// The pitch direction, expressed as a double. A value of 0 is level and a value of -90 is straight down. Values less than -90 or greater than 0 are ignored, and the pitch is set to -90.
},
SetPrintOptions: function(printOptions) {
/// This method controls how the map is printed.
/// A VEPrintOptions Class specifying the print options to set.
},
SetScaleBarDistanceUnit: function(distanceUnit) {
/// Sets the distance unit (kilometers or miles) for the map scale.
/// A VEDistanceUnit Enumeration value that specifies either miles or kilometers.
},
SetShapesAccuracy: function(policy) {
/// Specifies the accuracy in converting shapes when the map style is changed to birdseye.
/// The VEShapeAccuracy Enumeration value specifying the accuracy in converting shapes.
},
SetShapesAccuracyRequestLimit: function(max) {
/// Specifies the maximum number of shapes that are accurately converted at one time when the map style is changed to birdseye.
/// The maximum number of shapes that are accurately converted.
},
SetTileBuffer: function(numRings) {
/// Sets the number of "rings" of map tiles that should be loaded outside of the visible mapview area. This is also called tile overfetching.
/// An integer value greater than or equal to 0 that indicates the number of rings of additional tiles that should be loaded. The default is 0, and the maximum is 3.
},
SetTrafficLegendText: function(text) {
/// Specifies the text shown with the traffic legend, if visible.
/// A string specifying the text shown with the traffic legend.
},
SetZoomLevel: function(zoomLevel) {
/// Sets the view of the map to the specified zoom level.
/// The zoom level for the map. Valid values range from 1 through 19.
},
Show3DBirdseye: function(showBirdseye) {
/// Controls whether or not to show the Birdseye and BirdseyeHybrid map styles when the map mode is set to VEMapMode.Mode3D.
/// A Boolean value that specifies whether or not to show the Birdseye or BirdseyeHybrid map styles when the map mode is set to VEMapMode.Mode3D. The default is false.
},
Show3DNavigationControl: function() {
/// In 3D mode, shows the default user interface for controlling the map in 3D mode. By default, this control is shown.
},
ShowAllShapeLayers: function() {
/// Shows all shape layers on the map.
},
ShowControl: function(element) {
/// Makes the specified control visible. This method only affects control elements that have been hidden from view using the VEMap.HideControl Method.
/// An HTML element that contains the control to be shown.
},
ShowDashboard: function() {
/// Shows the default user interface for controlling the map (the compass-and-zoom control). By default, this control is shown.
},
ShowDisambiguationDialog: function(showDialog) {
/// Specifies whether the default disambiguation dialog is displayed when multiple results are returned from a location query using the VEMap.GetDirections Method.
/// A Boolean value. True enables the disambiguation dialog; false disables it.
},
ShowFindControl: function() {
/// Shows the Find control, which enables users to enter search queries.
},
ShowInfoBox: function(shape, anchor, offset) {
/// Shows an information box for the shape.
/// The reference to the shape for which an info box is to be shown. Required.
/// The anchor point where the info box is docked when displayed. This can either be a VELatLong Class object or a VEPixel Class object. This value must be a valid point on the current map. Optional.
/// If the anchor point is a VELatLong object, this parameter, a VEPixel object, specifies the anchor point's offset from that latlong position. Optional.
},
ShowMessage: function(message) {
/// Displays the specified message in a dialog box on the map.
/// The message you want to display on the map.
},
ShowMiniMap: function(xoffset, yoffset, size) {
/// Displays the mini map at the specified offset from the top left corner of the screen.
/// The x coordinate offset as a number of pixels from the top left corner of the screen. Optional.
/// The y coordinate offset as a number of pixels from the top left corner of the screen. Optional.
/// A VEMiniMapSize Enumeration value that specifies the mini map size. Optional. Default value is VEMiniMapSize.Small.
},
ShowScalebar: function() {
/// Displays the scale bar on the map.
},
ShowTileLayer: function(layerID) {
/// Shows a tile layer on the map.
/// The ID of the layer to be shown.
},
ShowTrafficLegend: function(x, y) {
/// Displays the traffic legend.
/// The x-coordinate of the top-left corner of the legend. Optional.
/// The y-coordinate of the top-left corner of the legend. Optional.
},
StartContinuousPan: function(x, y) {
/// Moves the map in the specified direction until the VEMap.EndContinuousPan Method is called.
/// The speed, as a percentage of the fastest speed, to move the map in the x direction. Positive numbers move the map to the right, while negative numbers move the map to the left.
/// The speed, as a percentage of the fastest speed, to move the map in the y direction. Positive numbers move the map down, while negative numbers move the map up
},
ZoomIn: function() {
/// Increases the map zoom level by 1. Valid values range from 1 through 19. If you call the ZoomIn method when the current zoom level is already at the maximum, the zoom level does not change.
},
ZoomOut: function() {
/// Decreases the map zoom level by 1. Valid values range from 1 through 19. If you call the ZoomOut method when the current zoom level is already at the minimum, the zoom level does not change.
}
}
VEMapMode = function()
{
/// ENUM: An enumeration of map modes.
/// Displays the map in the traditional two dimensions.
/// Loads the Virtual Earth 3D control, displays the map in three dimensions, and displays the 3D navigation control.
};
VEMapMode.Mode2D = null;
VEMapMode.Mode3D = null;
VEMapOptions = function()
{
/// Contains the options to set when loading the map.
/// A VEOrientation Enumeration value indicating the orientation of the bird's eye map. The default value is VEOrientation.North.
/// A Boolean value specifying whether or not to enable the Birdseye map style in the map control.
/// A Boolean value that specifies whether or not labels appear on the map when a user clicks the Aerial or Birdseye map style buttons on the map control dashboard.
/// A Boolean value indicating whether or not to load the base map tiles. The default value is true.
}
VEMapOptions.prototype =
{
BirdseyeOrientation: null,
EnableBirdseye : null,
EnableDashboardLabels : null,
LoadBaseTiles: null
}
VEMapStyle = function()
{
/// ENUM: An enumeration of map styles.
/// The road map style.
/// The shaded map style, which is a road map with shaded contours.
/// The aerial map style.
/// The hybrid map style, which is an aerial map with a label overlay.
/// The oblique map style, which is the same as Birdseye.
/// The bird's eye (oblique-angle) imagery map style.
/// The bird's eye hybrid map style, which is a bird's eye map with a label overlay
};
VEMapStyle.Road = null;
VEMapStyle.Shaded = null;
VEMapStyle.Aerial = null;
VEMapStyle.Hybrid = null;
VEMapStyle.Oblique = null;
VEMapStyle.Birdseye = null;
VEMapStyle.BirdseyeHybrid = null;
VEMapViewSpecification = function(center, zoom, altitude, pitch, heading)
{
/// Initializes a new instance of the VEMapViewSpecification object.
/// A VELatLong Class object that specifies the center point of the map. Required.
/// An integer that represents the zoom level of the map. In Mode2D: required; In Mode3D: ignored when altitude is specified.
/// If VEMapMode Enumeration is set to Mode3D, the altitude of the view, in meters above the geoid.
/// If VEMapMode Enumeration is set to Mode3D, the pitch of the view, in degrees. A value of –90 is straight down and a value of 0 is level.
/// If VEMapMode Enumeration is set to Mode3D, the heading of the view, in compass degrees. A value of 0 or 360 is true north.
}
VEMatchCode = function()
{
/// ENUM: A match code value as received from the geocoder.
/// No match was found.
/// The match was good.
/// The match was ambiguous.
/// The match was found by a broader search.
/// The match was found, but to a modified place.
};
VEMatchCode.None = null;
VEMatchCode.Good = null;
VEMatchCode.Ambiguous = null;
VEMatchCode.UpHierarchy = null;
VEMatchCode.Modified = null;
VEMatchConfidence = function()
{
/// ENUM: A match confidence value as received from the geocoder.
/// The confidence of a match is high.
/// The confidence of a match is medium.
/// The confidence of a match is low.
};
VEMatchConfidence.High = null;
VEMatchConfidence.Medium = null;
VEMatchConfidence.Low = null;
VEMiniMapSize = function()
{
/// ENUM: This enumeration represents the size of the mini map.
/// This represents a small mini map.
/// This represents a large mini map.
};
VEMiniMapSize.Small = null;
VEMiniMapSize.Large = null;
VEModelFormat = function() {
/// An enumeration of 3D model formats.
/// The 3D model data is in Wavefront OBJ format.
};
VEModelFormat.OBJ = null;
VEModelOrientation = function(heading, tilt, roll) {
/// Represents the orientation of a 3D model on the map.
/// A floating-point value specifying in decimal degrees the counter-clockwise rotation of the 3D model about the z-axis, looking along the positive z-axis away from the origin. Optional. The default value is 0.
/// A floating-point value specifying in decimal degrees the counter-clockwise rotation of the 3D model about the x-axis, looking along the positive x-axis away from the origin. Optional. The default value is 0.
/// A floating-point value specifying in decimal degrees the counter-clockwise rotation of the 3D model about the y-axis, looking along the positive y-axis away from the origin. Optional. The default value is 0.
/// A floating-point value specifying in decimal degrees the counter-clockwise rotation of the 3D model about the z-axis, looking along the positive z-axis away from the origin.
/// A floating-point value specifying in decimal degrees the counter-clockwise rotation of the 3D model about the y-axis, looking along the positive y-axis away from the origin.
/// A floating-point value specifying in decimal degrees the counter-clockwise rotation of the 3D model about the x-axis, looking along the positive x-axis away from the origin.
};
VEModelOrientation.prototype = {
Heading: null,
Roll: null,
Tilt: null
};
VEModelScale = function(x, y, z) {
/// Represents the scae of a 3D model with respect to the map.
/// A floating-point value specifying the x-axis scale factor of a 3D model. Optional. The default value is 1.
/// A floating-point value specifying the y-axis scale factor of a 3D model. Optional. The default value is 1.
/// A floating-point value specifying the z-axis scale factor of a 3D model. Optional. The default value is 1.
/// A floating-point value specifying the x-axis scale factor of a 3D model.
/// A floating-point value specifying the y-axis scale factor of a 3D model.
/// A floating-point value specifying the z-axis scale factor of a 3D model.
};
VEModelScale.prototype = {
X: null,
Y: null,
Z: null
};
VEModelScaleUnit = function() {
/// An enumeration of scale units.
/// Scale is defined in Inches.
/// Scale is defined in Feet.
/// Scale is defined in Yards.
/// Scale is defined in Millimeters.
/// Scale is defined in Centimeters.
/// Scale is defined in Meters.
};
VEModelScaleUnit.Inches = null;
VEModelScaleUnit.Feet = null;
VEModelScaleUnit.Yards = null;
VEModelScaleUnit.Millimeters = null;
VEModelScaleUnit.Centimeters = null;
VEModelScaleUnit.Meters = null;
VEModelSourceSpecification = function(modelFormat, modelSource, layer) {
/// Contains the specification for importing a 3D model onto the map.
/// A VEModelFormat Enumeration value specifying the data format of the 3D model being imported. Optional. The default value is VEModelFormat.OBJ.
/// A string specifying the URL of the 3D model data file. Required.
/// A VEShapeLayer Class specifying the shape layer into which the 3D model will be imported. Optional. If this parameter is not specified, the 3D model is added to the base layer.
/// A VEModelFormat Enumeration value specifying the data format of the 3D model being imported.
/// A VEShapeLayer Class specifying the shape layer into which the 3D model will be imported.
/// A string specifying the URL of the 3D model data file.
};
VEModelSourceSpecification.prototype = {
Format: null,
Layer: null,
ModelSource: null
};
VEModelStatusCode = function() {
/// An enumeration of status codes returned in callback of the VEMap.Import3DModel Method.
/// The 3D model was successfully loaded.
/// The 3D model failed to load because the given URL is invalid.
/// The 3D model failed to load. The file format may be incorrect.
};
VEModelStatusCode.Success = null;
VEModelStatusCode.InvalidURL = null;
VEModelStatusCode.Failed = null;
VEOrientation = function()
{
/// ENUM: An enumeration of orientations for bird's eye images.
/// The image was taken looking toward the North.
/// The image was taken looking toward the South.
/// The image was taken looking toward the East.
/// The image was taken looking toward the West.
};
VEOrientation.North = null;
VEOrientation.South = null;
VEOrientation.East = null;
VEOrientation.West = null;
VEPixel = function(x, y)
{
/// Initializes a new instance of the VEColor object.
/// The pixel's x coordinate.
/// The pixel's y coordinate.
/// Gets or sets the pixel's x coordinate.
/// Gets or sets the pixel's y coordinate.
}
VEPixel.prototype =
{
x: null,
y: null
}
VEPlace = function()
{
/// A found result returned from a location search.
/// Gets a VELatLong Class object that represents the best location of the found result.
/// An array of VEGeocodeLocation Class objects specifying all of the possible match results returned by the geocoder for this place.
/// Gets the String object that represents Virtual Earth's unambiguous name for the location.
/// A VEMatchCode Enumeration value specifying the match code from the geocoder. This property value is only valid for where-only searches.
/// A VEMatchConfidence Enumeration value specifying the match confidence from the geocoder. This property value is only valid for where-only searches.
/// A VELocationPrecision Enumeration value specifying the match precision from the geocoder for the best result, which is found in the VEPlace.LatLong property.
}
VEPlace.prototype =
{
LatLong: null,
Locations: null,
Name: null,
MatchCode: null,
MatchConfidence: null,
Precision: null
}
VEPrintOptions = function(enablePrinting)
{
/// Initializes a new instance of the VEPrintOptions class.
/// A Boolean value that represents whether or not to make the map printable. Required.
/// A Boolean value specifying whether or not to make the map printable.
}
VEPrintOptions.prototype =
{
EnablePrinting : null
}
VERoute = function()
{
/// Contains the route and itinerary information for a generated route. A VERoute object is returned to the callback when the VEMap.GetDirections Method is called.
/// A floating-point value that specifies the total length of the route.
/// An array of VERouteLeg Class objects that specify the intermediate legs of the route.
/// The total elapsed time, in seconds, to traverse the route.
};
VERoute.prototype =
{
Distance : null,
RouteLegs : null,
Time : null
}
VERouteDistanceUnit = function()
{
/// ENUM: An enumeration specifying the units used for the route.
/// The route is shown in units of miles.
/// The route is shown in units of kilometers.
};
VERouteDistanceUnit.Mile = null;
VERouteDistanceUnit.Kilometer = null;
VERouteHint = function() {
/// Specifies a route itinerary item hint.
/// A VERouteHintType Enumeration value specifying the type of the hint.
/// A string that describes the route itinerary item hint.
};
VERouteHint.prototype = {
Type: null,
Text: null
};
VERouteHintType = function() {
/// An enumeration specifying route itinerary item hint types.
/// The hint describes the intersection that comes before the itinerary item.
/// The hint describes the intersection that comes after the itinerary item.
/// The hint describes a landmark along the road or near the itinerary item.
};
VERouteHintType.PreviousIntersection = null;
VERouteHintType.NextIntersection = null;
VERouteHintType.Landmark = null;
VERouteItinerary = function()
{
/// Contains the itinerary information (step-by-step directions) of a VERoute Class object.
/// An array of VERouteItineraryItem Class objects specifying the step-by-step directions for the route.
};
VERouteItinerary.prototype =
{
Items : null
}
VERouteItineraryItem = function()
{
/// Specifies a step in the step-by-step directions of a route.
/// A floating-point number specifying the distance of the step
/// A VELatLong Class object specifying the position of the step
/// A VEShape Class object specifying the shape of the step
/// A String specifying the description of the step
/// The total elapsed time, in seconds, to traverse the route itinerary step.
/// An array of VERouteHint Class items that correspond to the itinerary item.
};
VERouteItineraryItem.prototype =
{
Distance : null,
LatLong : null,
Shape : null,
Text : null,
Time : null,
Hints: null
}
VERouteLeg = function()
{
/// Specifies the intermediate legs of the route.
/// A floating-point number specifying the length of the route leg.
/// A VERouteItinerary Class object specifying the itinerary of the route leg.
/// An integer specifying the total elapsed time, in seconds, to traverse the route leg.>
};
VERouteLeg.prototype =
{
Distance : null,
Itinerary : null,
Time : null
}
VERouteLocation = function()
{
/// Contains the location information (address and a latitude/longitude pair) of the VERouteDeprecated.StartLocation Property and VERouteDeprecated.EndLocation Property points of a route.
/// Specifies the street address (as a string) of the location.
/// Specifies the latitude and longitude (as a VELatLong Class) of the location.
};
VERouteLocation.prototype =
{
Address : null,
LatLong : null
}
VERouteMode = function()
{
/// ENUM: An enumeration of route modes.
/// The returned route contains driving directions.
/// The returned route contains walking directions.
};
VERouteMode.Driving = null;
VERouteMode.Walking = null;
VERouteOptimize = function()
{
/// ENUM: An enumeration specifying how a route is optimized.
/// The route is optimized to minimize time.
/// The route is optimized to minimize distance.
/// No route optimization is done. The route is calculated in the order in which the locations are specified.
};
VERouteOptimize.MinimizeTime = null;
VERouteOptimize.MinimizeDistance = null;
VERouteOptimize.Default = null;
VERouteOptions = function()
{
/// Provides optional attributes for a multi-point route.
/// A VERouteDistanceUnit Enumeration value specifying the units used by the route.
/// A Boolean value specifying whether the route is drawn on the map.
/// The name of the function called when the method has generated the route. Optional. The default value is null. The called function receives a VERoute Class object.
/// A VEColor Class object specifying the color of the route line.
/// A VERouteMode Enumeration value specifying the mode of route to return. The default value is VERouteMode.Driving.
/// A VERouteOptimize Enumeration value specifying how the route is optimized.
/// The thickness, in pixels, of the route line.
/// The z-index of the route line. The default value is 4.
/// A Boolean value specifying whether the map view is set to the best view of the route after it is drawn. The default is true, which means that the map view is set.
/// A Boolean value specifying whether a disambiguation dialog box is shown.
/// Whether to show any error messages.
/// A Boolean value specifying whether to use the MapPoint Web Service to generate the route.
/// A Boolean value specifying whether to calculate the route using traffic information.
}
VERouteOptions.prototype =
{
DistanceUnit : null,
DrawRoute : null,
RouteCallback : null,
RouteColor : null,
RouteMode : null,
RouteOptimize : null,
RouteWeight : null,
RouteZIndex : null,
SetBestMapView : null,
ShowDisambiguation : null,
ShowErrorMessages : null,
UseMWS : null,
UseTraffic : null
}
VERouteSegment = function()
{
/// Contains details about one segment of a VERoute Class object.
/// The driving instructions for this segment of the route.
/// The distance of this segment of the route.
/// A VELatLong Class object of the start point of this segment.
}
VERouteSegment.prototype =
{
Instruction: null,
Distance: null,
LatLong: null
}
VERouteType = function()
{
/// ENUM: An enumeration of route types.
/// Generates the shortest (by distance) route.
/// Generates the shortest (by estimated driving time) route.
};
VERouteType.Shortest = null;
VERouteType.Quickest = null;
VERouteWarning = function()
{
/// Specifies a traffic warning.
/// A VERouteWarningSeverity Enumeration value specifying the severity level of the warning.
/// A String that describes the route warning.
}
VERouteWarning.prototype =
{
Severity : null,
Text : null
}
VERouteWarningSeverity = function()
{
/// ENUM: An enumeration specifying the severity level of a route warning.
/// A warning which has no impact on traffic.
/// A warning which has low impact on traffic.
/// A minor traffic incident.
/// A moderate traffic incident.
/// A serious traffic incident.
};
VERouteWarningSeverity.None = null;
VERouteWarningSeverity.LowImpact = null;
VERouteWarningSeverity.Minor = null;
VERouteWarningSeverity.Moderate = null;
VERouteWarningSeverity.Serious = null;
VEShape = function(type, points)
{
/// Initializes a new instance of the VEShape class.
/// A VEShapeType Enumeration value of type that represents the type of shape. Required.
/// If the shape is a pushpin, this parameter can either be a single VELatLong Class object or an array of VELatLong objects. If it is an array of VELatLong objects, only the first VELatLong object is used to define the pushpin's location. Any additional data members are ignored. If the shape is a polyline or polygon, it must be an array of VELatLong objects, containing at least two points for a polyline and at least three points for a polygon. Required.
}
VEShape.prototype =
{
GetAltitude: function()
{
/// Returns the altitude for the shape. A floating-point value representing meters above the level represented by the altitude mode.
///
},
GetAltitudeMode: function()
{
/// Gets the mode in which the shape's altitude is represented. This method returns VEAltitudeMode.RelativeToGround if the altitude is not set.
///
},
GetCustomIcon: function()
{
/// Gets the VEShape objects custom icon. A String or VECustomIconSpecification object representing the custom icon of the VEShape object.
///
},
GetDescription: function()
{
/// Gets the description of the VEShape object. This description will be displayed in the shape's info box. A String object representing the description field of the VEShape object.
///
},
GetFillColor: function()
{
/// Gets the fill color and transparency for a polygon. The default is semi-transparent green (alpha=0.3, RGB=0, 128, 0). This method is ignored for pushpins and polylines.
///
},
GetIconAnchor: function()
{
/// Gets a VELatLong Class object representing the shape's custom icon anchor point.
///
},
GetID: function()
{
/// Gets the internal identifier of the VEShape object. Use this identifier when working with VEShape object events. A VEShape object only has an identifier when it has been added to a layer. If you try to get the identifier of a VEShape object that is not part of a layer, the VEShape.GetID method returns null.
///
},
GetLineColor: function()
{
/// Gets the line color or transparency for a polyline or polygon. A VEColor Class object representing the line color or transparency for a polyline or polygon. This method returns null for pushpins.
///
},
GetLineToGround: function()
{
/// Gets whether a line is drawn from the shape to the ground. If the shape type is Polyline or Polygon, this method returns a Boolean value; if the shape type is Pushpin, this method returns null.
///
},
GetLineWidth: function()
{
/// Gets the line width of a polyline or polygon. This method returns null for pushpins. If the line width is not set, the default value 2 is returned.
///
},
GetMaxZoomLevel: function()
{
/// Gets the maximum zoom level at which the shape is visible. The default maximum zoom level is 21.
///
},
GetMinZoomLevel: function()
{
/// Gets the minimum zoom level at which the shape is visible. The default minimum zoom level is 1.
///
},
GetMoreInfoURL: function()
{
/// Gets the string containing the URL of the "more info" link that is displayed in the shape's info box.
///
},
GetPhotoURL: function()
{
/// Gets the shape's "photo" URL.
///
},
GetPoints: function()
{
/// Returns an array of VELatLong objects representing the points that make up the pushpin, polyline, or polygon.
///
},
GetShapeLayer: function()
{
/// Gets the reference to the layer containing the specified VEShape object.
///
},
GetTitle: function()
{
/// Gets the title of the VEShape object.
///
},
GetType: function()
{
/// Gets the type of the VEShape object.
///
},
GetZIndex: function()
{
/// Gets the z-index of a pushpin shape or pushpin attached to a polyline or polygon.
///
},
GetZIndexPolyShape: function()
{
/// Gets the z-index for a polyline or polygon.
///
},
Hide: function()
{
/// Hides the specified VEShape object from view.
},
HideIcon: function()
{
/// Hides the icon associated with a polyline or polygon. This method is ignored for pushpins.
},
IsModel: function()
{
/// Returns whether the shape is a model.
///
},
SetAltitude: function(altitude, altitudeMode)
{
/// Specifies the altitude for the shape.
/// A floating-point value or array of floating-point values specifying the altitude, in meters, of the shape.
/// A VEAltitudeMode Enumeration value specifying the mode in which the shape's altitude is represented.
///
},
SetAltitudeMode: function(mode)
{
/// Specifies the mode in which a shape's altitude is represented.
/// A VEAltitudeMode Enumeration value specifying the altitude representation.
},
SetCustomIcon: function(customIcon)
{
/// Sets the VEShape object's custom icon.
/// A String object containing either a URL to an image, custom HTML that defines the custom icon, or a VECustomIconSpecification object.
},
SetDescription: function(details)
{
/// Sets the description of the VEShape object.
/// A String object containing either plain text or HTML that represents the VEShape object's description field.
},
SetFillColor: function(color)
{
/// Sets the fill color and transparency of a polygon.
/// A VEColor object representing the fill color and transparency.
},
SetIconAnchor: function(point)
{
/// Sets the info box anchor of the VEShape object.
/// A VELatLong Class object representing the shape's info box anchor point.
},
SetLineColor: function(color)
{
/// Sets the line color or transparency for a polyline or polygon.
/// A VEColor Class object representing the line color and transparency.
},
SetLineToGround: function(extrude)
{
/// Specifies whether a line is drawn from the shape to the ground.
/// A Boolean value specifying whether a line is drawn from the shape to the ground.
},
SetLineWidth: function(width)
{
/// Sets the line width for a polyline or polygon.
/// An integer representing the line's width.
},
SetMaxZoomLevel: function(level)
{
/// Sets the maximum zoom level at which the shape is visible.
/// An integer specifying the maximum zoom level.
},
SetMinZoomLevel: function(level)
{
/// Sets the maximum zoom level at which the shape is visible.
/// An integer specifying the minimum zoom level.
},
SetMoreInfoURL: function(moreInfoURL)
{
/// Sets the shape's "more info" URL.
/// A String object containing the URL of the "more info" link that is displayed in the shape's info box.
},
SetPhotoURL: function(photoURL)
{
/// Sets the shape's photo URL.
/// The string containing the URL of the image that is displayed in the shape's info box.
},
SetPoints: function(points)
{
/// Sets the points of the VEShape Class object.
/// An array of VELatLong Class objects.
},
SetTitle: function(title)
{
/// Sets the title of the VEShape object. This title will be displayed in the shape's info box.
/// A String object containing either plain text or HTML that represents the VEShape object's title.
},
SetZIndex: function(icon, polyshape)
{
/// Sets the maximum zoom level at which the shape is visible.
/// Optional. An integer specifying the z-index for the shape's icon (or for the pushpin if the shape is a pushpin). If this value is null or undefined the z-index is not changed.
/// Optional. An integer specifying the z-index for the shape. This parameter is ignored if the shape is a pushpin. If this value is null or undefined the z-index is not changed.
},
Hide: function()
{
/// Makes the specified VEShape object visible.
},
ShowIcon: function()
{
/// Shows the icon associated with a polyline or polygon. This method is ignored for pushpins.
}
}
VEShapeAccuracy = function()
{
/// ENUM: Specifies the accuracy of shape conversions when the map style is changed to birdseye.
/// No shapes are accurately converted
/// Only pushpins are accurately converted
};
VEShapeAccuracy.None = null;
VEShapeAccuracy.Pushpin = null;
VEShapeLayer = function() {
/// Initializes a new instance of the VEShapeLayer class.
}
VEShapeLayer.prototype =
{
AddShape: function(shape) {
/// Adds a VEShape Class object or array of VEShape objects to the layer.
/// The VEShape object or array of VEShape objects to be added. Required.
},
DeleteAllShapes: function() {
/// Deletes all VEShape Class objects (pushpins, polylines, and polygons) from the layer.
},
DeleteShape: function(shape) {
/// Adds a VEShape Class object or array of VEShape objects to the layer.
/// A reference to the VEShape object (pushpin, polyline, and polygon) to delete. Required.
},
GetBoundingRectangle: function() {
/// Returns a best-fit VELatLongRectangle Class object based on the shapes currently present in the layer.
///
},
GetClusteredShapes: function(type) {
/// Returns an array of VEClusterSpecification Class objects representing the calculated pushpin clusters.
/// A VEClusteringType Enumeration specifying the algorithm used to determine which pushpins to cluster.
///
},
GetDescription: function() {
/// Gets the description of the VEShapeLayer object.
///
},
GetShapeByID: function(id) {
/// Retrieves a reference to a VEShape Class object contained in this layer based on the specified ID.
/// The identifier of the VEShape object. Required.
///
},
GetShapeByIndex: function(index) {
/// Retrieves a reference to a VEShape Class object contained in this layer based on the specified index.
/// The index of the shape to retrieve. Required.
///
},
GetShapeCount: function() {
/// Returns the total number of shapes in the current layer.
///
},
GetTitle: function() {
/// Gets the title of the VEShapeLayer Class object.
///
},
Hide: function() {
/// Hides the layer from view on the map.
},
IsVisible: function() {
/// Returns true if the layer is visible, otherwise returns false.
///
},
SetClusteringConfiguration: function(type, options) {
/// Sets the method for determining which pushpins are clusted as well as how the cluster is displayed.
/// A VEClusteringType Enumeration specifying which shapes to cluster, OR the name of the function used to determine which pushpins are clustered. The function must accept a VEShapeLayer Class object and return an array of VEClusterSpecification Class objects. Required.
/// A VEClusteringOptions Class object specifying how the pushpin cluster is displayed. Optional.
},
SetDescription: function(details) {
/// Sets the description of the VEShapeLayer object.
/// A String object containing either plain text or HTML that represents the VEShapeLayer object's description field.
},
SetTitle: function(title) {
/// Sets the title of the VEShapeLayer object.
/// A String object containing either plain text or HTML that represents the VEShapeLayer object's title.
},
Show: function() {
/// Shows the layer on the map.
}
}
VEShapeSourceSpecification = function(dataType, dataSource, layer)
{
/// Initializes a new instance of the VEShapeSourceSpecification object.
/// A VEDataType Enumeration that specifies the type of data to import. Required.
/// A URL representing the GeoRSS feed or KML data, or a globally-unique identifier (GUID) representing the Live Maps collection. Required.
/// A VEShapeLayer Class object in which the VEShape objects are contained after importing. If this parameter value is null, the VEShape objects are added to the base layer.
/// A VEShapeLayer Class object in which the VEShape objects are contained after importing.
/// A String specifying the layer source.
/// Specifies the maximum number of items that can be imported from an XML file. The default value is 200.
/// A VEDataType Enumeration value defining the type of data to be imported into a shape layer.
}
VEShapeSourceSpecification.prototype =
{
Layer: null,
LayerSource: null,
MaxImportedShapes: null,
Type: null
}
VEShapeType = function()
{
/// ENUM: An enumeration of the Shape types.
/// This represents a Shape object that is a pushpin.
/// This represents a Shape object that is a polyline.
/// This represents a Shape object that is a polygon.
};
VEShapeType.Pushpin = null;
VEShapeType.Polyline = null;
VEShapeType.Polygon = null;
VETileSourceSpecification = function(tileSourceId, tileSource, numServers, bounds, minZoom, maxZoom, getTilePath, opacity, zindex)
{
/// Initializes a new instance of the VETileSourceSpecification object.
/// A unique identifier for the layer. Each layer on a map must have a unique Identifier. Required.
/// The location of the tiles. Required.
/// The number of servers on which the tiles are hosted. Optional. The default value is 1.
/// An array of VELatLongRectangle Class objects that specifies the approximate coverage area of the layer. Optional.
/// The minimum zoom level at which to display the custom tile source. Optional.
/// The maximum zoom level at which to display the custom tile source. Optional.
/// When viewing a map in 2D mode, the function that determines the correct file names for the tiles. Optional.
/// The opacity level of the tiles when displayed on the map. 0.0 to 1.0. Optional.
/// The z-index value for the tiles. Optional.
/// An array of VELatLongRectangle Class objects that specifies the approximate coverage area of the layer.
/// The unique identifier for the layer. Each tile layer on a map must have a unique ID.
/// The maximum zoom level at which to display the custom tile source.
/// The minimum zoom level at which to display the custom tile source.
/// The number of servers on which the tiles are hosted.
/// Specifies the opacity level of the tiles when displayed on the map. 0.0 to 1.0.
/// The location of the tiles.
/// Specifies the z-index for the tiles.
}
VETileSourceSpecification.prototype =
{
Bounds: null,
ID: null,
MaxZoom: null,
MinZoom: null,
NumServers: null,
Opacity: null,
TileSource: null,
ZIndex: null
}