JavaScript API Reference

The encompassing namespace for the entire GeoStream v2.0 JavaScript API. This serves largely as a container for other packages targeted for a more specific role, but also contains common types and utility functions that affect the functionality of the entire library. There are two main types of entity in this library: classes and namespaces. Classes are constructor functions that should be called with the new keyword (managed classes will throw an exception if they are called without it) to create an object with all the properties specified by the class. Most GeoBase classes are managed: they can be inherited from, and undergo several small automatic validations. However, some small classes that are intended to be constructed repeatedly in performance-critical contexts (such as LatLon and Point) are unmanaged, and lack these features. Methods of a class instance should only be called as properties of that instance (or with an apply or call scope adjustment). The following usage is invalid and will generally result in an error:

var instance = new SomeClass ();
var writeCallback = instance.write;
...
writeCallback ('text');

and instead, the following should be written:

var instance = new SomeClass ();
var writeCallback = function (text) {instance.write (text);};
...
writeCallback ('text');

Namespaces are groupings of items with a common purpose. Functions in a namespace are scope-independent, so they may be called by direct reference rather than as properties of the namespace itself (although this latter approach is more common). That is, the following is valid (though it would not be for a class instance):

var writeCallback = SomeNamespace.write;
...
writeCallback ('text');

Notice that many GeoBase objects and classes contain internal properties, marked with a leading '_' character. These objects and classes should never be used directly. Such properties are made inaccessible wherever possible, but sometimes true-private variables are not viable with the use of JavaScript prototypes, in order to allow faster class instantiation.

An abstract base class for constructs that are based on a DOM element, such as map layers and widgets. Primarily, this combines the features of MapLayers.AbstractLayer and Widgets.AbstractWidget to allow code re-use. Note that because of the varying treatments of top-level DOM nodes between these, creation of a base element is left to the derived class.

Contains functions for formatting the addresses found by geocodes for different cultures.

Contains methods that format address objects over GeoStream, using the GeoStream.Server.JSONAddressFormatter.

Represents both the input address and the address found from the input.

A class that inherits Addresses.IAddressData. Represents an address that is structured at the suburb level and above, however the street address (building name, street number, street name, etc) is a single string. Structured forward geocodes will store the RawAddress as an Addresses.IStreetAddressData.

A class that inherits Addresses.IAddressData. Represents an address that is structured at the suburb level and above, however the street address (building name, street number, street name, etc) is a single string. Structured forward geocodes will store the RawAddress as an Addresses.IStreetAddressData.

StructuredAddressData represents an address that has been fully structured and allows specific details of the address to be stored and retrieved.

A namespace enclosing GeoBase functions for manipulating arrays. Normally, these would be attached to the Array prototype, but this is avoided to maintain compatibility with some other libraries.

Used to provide authentication services with GeoStream servers using only JavaScript. Necessary when providing GeoStream authentication from non .NET environments or services.

Contains functions for sending the GeoStream server a partial address query while the user is typing, in order to return region or street suggestions for the user to choose from. Note that you can enable the GeocodingLogging option to monitor GeoStream geocoding performance. For more information see web.config

Represents the values returned from the GeoStream server as the result of an auto-complete geocoding operation. Contains the search status (whether the search was completed or indeterminate) and an array of AutocompleteGeocoder.Suggestions.

Two suggestion types are supported by this class: regions and street addresses. Region suggestions come with a bounding box value to be zoomed to on the map. A street address suggestion can be a street-name-only suggestion, which enables the user to select a whole street name instead of having to type it to the end, or a full address suggestion, which can describe a particular LatLon on the map along with the full name of the address.

Represents a rectangular area between top-left and bottom-right corners, specified as latitude-longitude coordinates. Potentially useful for zooming, or hit-testing a given area.

// Create a BoundingBox in Los Angeles, Ca
var BBox = new Telogis.GeoBase.BoundingBox(
    new Telogis.GeoBase.LatLon(33.587137,-117.742878),
    new Telogis.GeoBase.LatLon(33.575037,-117.724762)
);

A utility for managing and rendering primitive shapes to a VML (Internet Explorer v8 or less) or SVG (Webkit) element. Shapes are managed as individual entities, as is the style of vector-graphics implementations like VML and SVG, for performance reasons. That is, to draw on a canvas once it has been created, methods to create these primitives should be called (e.g. Canvas.circle, Canvas.rect), but if further manipulation of them is desired (e.g. to clear the Canvas), references to the objects returned by these functions should be kept and have appropriate methods called.

// Create a Canvas instance on a parent DOM element (DIV 'main_map')
var myCanvas = new Telogis.GeoBase.Canvas({
    fillColor: new Telogis.GeoBase.Color(0,18,255,0.5),
    id: 'new_canvas',
    lineColor: new Telogis.GeoBase.Color(0,18,255,0.9),
    lineWidth: 1,
    parent: 'main_map', // DOM entity. In this example the DIV 'main_map'
    size: new Telogis.GeoBase.Size(640,480) // Not needed if already defined
});

A class for managing and rendering a group of primitive shapes to a VML (Internet Explorer v8 or less) or SVG (Webkit) element. This class renders to a <group> element in VML or <g> element in SVG. Shapes can be added to or removed from a group. A group of shapes can be shown/hidden altogether.

A namespace containing the classes for the different types of primitive shape that can be constructed on a Canvas object.

An abstract base class for every type of primitive, defining the basic functionality and structure common to all. Derivations of this should be created and returned by Canvas drawing calls, and never constructed explicitly. Their properties may be manipulated directly, but changes to them will only be made visible once Canvas.Shapes.AbstractShape.draw is called (usually from Canvas.update. This constructor performs the registration of the Canvas.Shapes.AbstractShape within the calling Canvas, and also sets up the DOM sub-tree for the shape, if necessary.

Represents an ellipse of standard (horizontal) orientation, as displayed in a Canvas renderer. This should not be constructed explicitly, but rather generated as the result of a call to Canvas.ellipse or Canvas.circle.

Represents an image, as displayed in a Canvas renderer. This should not be constructed explicitly, but rather generated as the result of a call to Canvas.image.

Represents a label, as displayed in a Canvas renderer. This should not be constructed explicitly, but rather generated as the result of a call to Canvas.Label.

Represents an arbitrary figure described by a sequence of commands, as displayed in a Canvas renderer. This should not be constructed explicitly, but rather generated as the result of a call to Canvas.path.

Represents a polyline between a collection of arbitrary points, as displayed in a Canvas renderer. This should not be constructed explicitly, but rather generated as the result of a call to Canvas.polyline.

Represents a rectangle of standard (horizontal-vertical) orientation, as displayed in a Canvas renderer. This should not be constructed explicitly, but rather generated as the result of a call to Canvas.rect.

Contains useful functions for manipulating the array of pixel points prior to rendering.

Contains helper methods for sending requests to the GeoStream CDOLT server. Internal use only.

Contains functions for manipulating and validating managed GeoBase classes.

Provides classes to support generating and displaying map features in clusters when they are close together.

A cluster that represents multiple items on the map that are spatially close together relative to the map zoom.

The ClusterSet class represents a collection of Clusters.

Represents a set of color components in RGB-space, with an optional alpha-value.

Manages a diagnostic console for displaying messages about program execution and flow throughout the lifetime of the application.

Internal use only.

Contains RPC methods used to fetch miscellaneous GIS data from the GeoStream server.

Contains information about a data set available on the current GeoStream server.

A collection of values representing the various distance units that can be used with MathUtil. While each of these values should be used primarily as a code to represent its corresponding unit, it is also the string abbreviation of the unit and can thus be used for labelling.

A namespace containing the various custom error classes -- all of which are derivations of the built-in Error class -- that may be thrown by the API.

Represents an exception thrown due to a problem requesting and/or receiving dynamic content, either with an XML HTTP request or script inclusion.

Represents an error thrown when a parameter passed to a function is of an invalid type.

Represents an error thrown when a parameter passed to a function is of an invalid value.

Represents an exception that has occurred due to an authentication failure.

Represents an exception occurring during the definition of a class using the Class subsystem.

Represents an exception arising from an invalid construction of a configured class.

Represents an exception thrown when an invalid number was found where an enumerated value was expected.

The derivation of the built-in Error type from which all GeoBase API exceptions are derived.

Represents an exception thrown due a problem serializing or deserializing JSON data used to communicate with the server.

Represents an exception arising from invalid layout of some DOM element on the page.

Represents an exception thrown when a method is called on an object before the object is sufficiently initialized to perform that action.

Represents an exception thrown by a server-side invocation (a remote procedure call).

Represents an exception thrown when this is of an unexpected type, i.e. a function is being executed in an invalid scope.

Represents an exception arising from a timeout in fetching some resource.

Represents an exception that occurred while performing operations on an XML document.

Provides a way to organize a collection of functions and call them all at once when a certain event occurs. Other EventHandlers can also be queued for execution once the calling handler has been triggered, but less flexibility is available than for functions.

A wrapper class to contain information about a point of interest in the map data.

Contains functions for sending forward- and reverse-geocoding requests to the GeoStream server. Note that you can enable the GeocodingLogging option to monitor GeoStream geocoding performance. For more information see web.config

Represents the physical address returned by reverse geocoding.

Represents a LatLon and a physical address, returned as the result of GeoCoding.

A composite object that represents the result of a reverse geocoding call.

Represents a LatLon and a physical address, returned as the result of GeoCoding.

Represents a generic (or 'unknown') LatLon and a physical address. It contains no more than a street address, city, zip code and region.

Represents a LatLon and a physical address, returned as the result of GeoCoding in the United States.

Contains geometry classes.

A geometric line described by a string of points.

Represents the physical shape of a closed polygonal area such as a lake or national park. Not to be confused with a Polygon, which is an object containing an array of geometries such as Geometry.Polygons.

Represents a closed curve that forms part of a polygon. This may be the outer perimeter or a ring around a "gap" such as an island in a lake.

Contains mathematical utility functions for manipulating spatial data.

Contains helper methods for sending requests to the GeoStream server.

A wrapper class for containing data relating to GeoStream server requests. This is used as a container to implicitly pass method and authentication information to the server.

A wrapper class that contains information returned from the GeoStream server.

Contains functions for formatting the addresses found by geocodes for different cultures.

Represents a column in a Telogis.Geobase.GeoStream.Server.CustomDataTable.

Represents a table in the layer.

Represents a layer of custom data on a CDOLT server.

Represents an index in the layers data.

The result returned from an index query on a layer.

A class to be filled with error information from the server.

Represents a latitude-longitude coordinate pair, expressed in degrees (WGS84 World Geodetic System projection).

Represents a non-street line feature, such as a railway, stream or custom line data.

Contains all types of layer that can be added to a GeoStream map. This also acts as a global hash for all instantiated derivations of MapLayers.AbstractLayer, so that if a reference is not kept to such an object, it can be accessed like so:

var MapLayers   = Telogis.GeoBase.MapLayers;
var Map         = Telogis.GeoBase.Widgets.Map;
var ObjectLayer = Telogis.GeoBase.MapLayers.ObjectLayer;

var map = new Map ({id: 'main_map'});
new ObjectLayer ({id: 'pin_layer', map: map});

var layer = MapLayers ['pin_layer'];

An abstract class for handling layers on a GeoStream map. Any such map in GeoStream is composed of a number of these layers which should all derive from this class. A MapLayers.TileLayer is added implicitly with the creation of the map, but other types need to be added separately. Note also that the layer created by this constructor is automatically added to the map if one is specified.

An abstract class for map objects that can be displayed in a MapLayers.ObjectLayer. Should not typically be called directly, but instead inherited by objects created using MapLayers.ImageObject and MapLayers.IndexedImageObject.

// ** This example displays a balloon on a map. The balloon text, when clicked, will trigger a function (an alert).
// At the top of your .aspx file, add a script reference to "/scripts/skin.balloon.greygradient.js". This defines a default balloon skin style.
// Create a Telogis.GeoBase.MapLayers.BalloonSkin with default properties to apply to AbstractObject.config.balloonConfig.skin.
var myBalloonSkin = new Telogis.GeoBase.MapLayers.BalloonSkin();

// Create content and an arbitrary function to call using AbstractObject.config.balloonConfig.contentFunc
var newDiv = document.createElement('Div');
newDiv.appendChild(document.createTextNode('Click Me'));
newDiv.onclick = function() {alert('You clicked the balloon!')}; // Click the balloon to activate an alert

// Create an AbstractObject instance on the map ('map') with a balloon containing text
// No image (src) can be specified: use Telogis.GeoBase.MapLayers.ImageObject for this functionality.
// AbstractObject is typically used only to provide inheritance.
var myAbstractObject = new Telogis.GeoBase.MapLayers.AbstractObject({
    anchorPoint: new Telogis.GeoBase.Point(0.5,0.0),
    balloonConfig: {
        //content: 'This is plain text', // Text content for the balloon.
        // --- either content or contentFunc should be used, not both
        contentFunc: function() {return newDiv}, // A function to provide balloon content as HTML
        show: true, // Show on initial loading
        hAlign: Telogis.GeoBase.MapLayers.Balloon.ALIGN_RIGHT, // Horizontal alignment of the balloon
        vAlign: Telogis.GeoBase.MapLayers.Balloon.ALIGN_BOTTOM, // Vertical alignment of the balloon
        skin: myBalloonSkin // The skin to apply to the balloon
    },
    dragEnabled: false,
    location: new Telogis.GeoBase.LatLon(33.587137,-117.742878), // The location (Los Angeles). Overridden if also specified in balloonConfig
    map: map, // May also be referenced as 'parent'. This example assumes a map named 'map' exists
});

See MapLayers.BalloonSkin for an example of customising a balloon skin.

A simple balloon that can be associated with a marker on a map and used to display a small amount of text or HTML content.

// ** This example displays a balloon on a map. The balloon text, when clicked, will trigger a function (an alert)
// Create a Telogis.GeoBase.MapLayers.BalloonSkin to apply to balloon.config.skin.
var myBalloonSkin = new Telogis.GeoBase.MapLayers.BalloonSkin({
    bodyStyle: { // specify the style of the balloon and its text
        backgroundColor: "#ffffff",
        border:          "1px solid black",
        color:           "#000000",
        fontFamily:      "sans-serif",
        fontSize:        "20px",
        fontWeight:      "normal",
        padding:         "10px",
        textAlign:       "center",
        verticalAlign:   "middle",
        width:           "150px"
    },
    folder: "http://localhost/GeoStream/scripts/images/skins/balloon/directedwhite/", // specify the default images folder
    tagAnchorPoint: new Telogis.GeoBase.Point(0.0, 1.0), // specify the bottom-left image position
    tagOverlap: -7, // adjust the vertical position of the balloon tag (move bottom-left image and tag closer/further apart)
    bottomLeftTagSrc: 'tag-bottom-left.png', // image used for bottom-left balloon tag corner (relative to 'folder')
    bottomRightTagSrc: 'tag-bottom-right.png', // image used for bottom-right balloon tag corner
    topLeftTagSrc: 'tag-top-left.png', // image used for top-left balloon tag corner
    topRightTagSrc: 'tag-top-right.png' // image used for top-right balloon tag corner
});

// Create an arbitrary function to call using balloon.config.contentFunc
var newDiv = document.createElement('Div');
newDiv.appendChild(document.createTextNode('Click Me'));
newDiv.onclick = function() {alert('You clicked me!')}; // Click the balloon to activate an alert

// Create a Balloon instance on the map ('map') with a balloon containing text
var myBalloon = new Telogis.GeoBase.MapLayers.Balloon({
    dragEnabled: true,
    //content: "<a href='http://www.telogis.com'>Telogis</a>", // Text or HTML content for the balloon.
    // --- either content or contentFunc should be used, not both
    contentFunc: function() {return newDiv}, // A function to provide balloon content as HTML
    hAlign: Telogis.GeoBase.MapLayers.Balloon.ALIGN_RIGHT, // Horizontal alignment of the balloon
    location: new Telogis.GeoBase.LatLon(33.587137,-117.742878),
    show: true, // Show on initial load
    skin: myBalloonSkin, // The skin to apply to the balloon
    vAlign: Telogis.GeoBase.MapLayers.Balloon.ALIGN_BOTTOM, // Vertical alignment of the balloon
    map: map // May also be referenced as 'parent'
});

A simple class that combines all the information describing the appearance of a balloon. Several predefined instances are available as static properties of the MapLayers.BalloonSkin class, and can be used to theme balloons reasonably painlessly.

var myBalloonSkin = new Telogis.GeoBase.MapLayers.BalloonSkin({
    bodyStyle: { // specify the style of the balloon and its text
        backgroundColor: "#ffffff",
        border:          "1px solid black",
        color:           "#000000",
        fontFamily:      "sans-serif",
        fontSize:        "20px",
        fontWeight:      "normal",
        padding:         "10px",
        textAlign:       "center",
        verticalAlign:   "middle",
        width:           "150px"
    },
    folder: "images/skins/balloon/directedwhite", // specify the default images folder
    tagAnchorPoint: new GeoBase.Point(0.0, 1.0), // specify the bottom-left image position
    tagOverlap: 1, // adjust the vertical position of the balloon tag (move bottom-left image and tag closer/further apart)
    bottomLeftTagSrc: 'tag-bottom-left.png', // image used for bottom-left balloon tag corner (relative to 'folder')
    bottomRightTagSrc: 'tag-bottom-right.png', // image used for bottom-right balloon tag corner
    topLeftTagSrc: 'tag-top-left.png', // image used for top-left balloon tag corner
    topRightTagSrc: 'tag-top-right.png' // image used for top-right balloon tag corner
});

A class for displaying primitive drawing objects with VML / SVG on a layer.

// Create a CanvasLayer
myCanvasLayer = new Telogis.GeoBase.MapLayers.CanvasLayer({
    id: 'canvas_layer',
    parent: map,
    fillColor: new Telogis.GeoBase.Color(0,18,255,0.5),
    lineColor: new Telogis.GeoBase.Color(0,18,255,0.9),
    lineWidth: 2,
    show: true
});

A circular form of geofence, as described by a coordinate-pair center point and a distance radius in some fixed units.

// Create a CircleFence in Los Angeles with a radius of half a mile
myCircleFence = new Telogis.GeoBase.MapLayers.CircleFence({
    id: 'circle_fence',
    parent: map,
    center: new Telogis.GeoBase.LatLon(33.575131,-117.778007),
    radius: 0.5,
    units: Telogis.GeoBase.DistanceUnit.MILES,
    fillColor: new Telogis.GeoBase.Color(0,18,255,0.2),
    lineColor: new Telogis.GeoBase.Color(0,18,255,0.9),
    lineWidth: 1,
    show: true
});

Creates a layer to contain multiple MapLayers.ImageObject instances, which displays cluster icons for clusters obtained from a given datasource.

A class for displaying arbitrary HTML in a DIV on an MapLayers.ObjectLayer.

An extension of a MapLayers.LayerCollection specifically for MapLayers.GeoFences that also provides a MapLayers.FenceCollection.contains method.

A class used for displaying a customizable (not necessarily rectangular, as is the restriction of a MapLayers.RegionShadeLayer) region on a map, so as to indicate an area not accessible for routing or one that has some other significance.

A class for displaying images on a map via an MapLayers.ObjectLayer.

// Render an image on the map ('map') with a balloon containing text
var myImageObject = new Telogis.GeoBase.MapLayers.ImageObject({
    scalable: true, // true to allow the image size to be changed, false to lock size
    src: 'images/pin-red.png', // The path to the image file used
    balloonConfig: { // Configuration options for the balloon
        content: 'Balloon Text', // text to display in the balloon
        show: true // true to display the balloon on load
    },
    anchorPoint: new Telogis.GeoBase.Point(0.5,0.0),
    map: map,
    location: new Telogis.GeoBase.LatLon(33.587137,-117.742878), // Where the image will be drawn
});

Functionally the same as an MapLayers.ImageObject, except that it displays a small index associated with the object over the image.

A wrapper class that contains multiple map layers so that they can be treated as a single layer. While such a collection can be referenced by ID, it is not bound to any specific map.

Creates a layer to contain multiple Telogis.GeoBase.MapLayer.AbstractObject instances, which allow icons to be displayed on a map. An R-tree may be used to store the objects and cull those that do not lie on the map. All objects placed on the layer can be accessed by subscripting the MapLayers.ObjectLayer instance with their IDs, like so:

var ImageObject = Telogis.GeoBase.MapLayers.ImageObject;
var LatLon      = Telogis.GeoBase.LatLon;
var Map         = Telogis.GeoBase.Widgets.Map;
var ObjectLayer = Telogis.GeoBase.MapLayers.ObjectLayer;

var map   = new Map         ({id: 'main_map'});
var layer = new ObjectLayer ({id: 'pin_layer', map: map});

new ImageObject ({

    id:       'pushpin',
    layer:     layer,
    location:  new LatLon (34.067, -118.000),
    src:      'pin.png'
});
var pin = layer ['pushpin'];

A variant of MapLayers.GeoFence that represents a region defined by the closure of an arbitrary polyline.

A class for displaying a shaded rectangular region on a map.

A class used for displaying a path or route described by a sequence of latitude-longitude coordinates. This may be constructed with the directions generated by a routing call. Note also that this layer can be used for any arbitrary path: not necessarily ones generated by routing calls.

// Method 1:
// First create a route (myRoute) and a map object (map)
// Then use getDirections or getQuickDirections to retrieve directions
myRoute.getQuickDirections(function (result) {
    // Wrap the RouteLayer constructor within the callback function
    directionsRouteLayer = new Telogis.GeoBase.MapLayers.RouteLayer({
        id: 'route_directions',
        map: map,
        // Pass the directions object to the RouteLayer
        directions: result,
        lineColor: new Telogis.GeoBase.Color(0,18,255,0.5),
        lineWidth: 4,
        show: true
    });
    }, function (error) {alert(error)}
);

// Method 2:
// Or, alternatively, create a RouteLayer object without directions
myRouteLayer = new Telogis.GeoBase.MapLayers.RouteLayer({
    id: 'route_directions',
    map: map,
    lineColor: new Telogis.GeoBase.Color(0,18,255,0.5),
    lineWidth: 4,
    show: true
});

// Then use getDirections or getQuickDirections to set the points of the RouteLayer
// setPoints may also be used with an arbitrary array of LatLons
myRoute.getQuickDirections(function (result) {
    myRouteLayer.setPoints(result.getPoints());
    myRouteLayer.show();
    }, function (error) {alert(error)}
);

Creates a layer that is responsible for displaying the generated tiles from the tile server.

Creates a layer that displays a scaled transition in place of some existing MapLayers.TileLayer when it is zoomed.

Creates a layer that is responsible for displaying traffic tiles from the tile server.

A class for displaying a shaded rectangular region on a map to correspond to the viewport of another map.

Creates a layer that is responsible for displaying displaying WMS overlay tiles from the tile server. This class can be used to display tiles generated from a single WMS source, or from two WMS sources composited together and served as a single set of tiles.

Creates a layer to contain a large number of objects that are read from an XML file and displayed. It uses XSLT for handling object clipping to the viewport, which loads more quickly than the RTree used in MapLayers.ObjectLayer at the cost of flexibility. Markers are loaded cell-by-cell in a grid (whose pitch may be specified with the MapLayers.XSLTObjectLayer.config.cellCount configuration property) and are specified by data read from the XML by specified XPath expressions (relative to each marker tag). Note: In IE9, you must add the following header to the HTML file when using XSLTObjectLayer:

<meta http-equiv="X-UA-Compatible" content="IE=8">

A map object used to briefly display a zooming image at the focal point of a map's zoom, making it clear how the map is being centered.

Contains mathematical utility functions for manipulating spatial data.

A namespace enclosing GeoBase functions for manipulating objects. Normally, these would be attached to the Object prototype, but this is avoided to maintain compatibility with some other libraries.

A description of a point of interest returned by the server, grouping additional information about it such as name and phone number.

// Create a BoundingBox in Los Angeles
var QueryBox = new Telogis.GeoBase.BoundingBox(
    new Telogis.GeoBase.LatLon(33.893487,-118.252747),
    new Telogis.GeoBase.LatLon(33.886426,-118.234481)
);

var list = '';
var myQuery = ''; // An empty string or null returns all POIs.
// Also accepts partial matches to POI names (not types), for example 'Airport' or 'Museum'.
// Or a full name, such as 'Acme Fish Market' or 'Tasty Cupcakes By Angelo'.

// Query every POI within the BoundingBox
Telogis.GeoBase.DataQuery.queryPOI(QueryBox, null, myQuery, function (result) {
    for (var i = 0; i < result.length; i++) {
        var checkFood = result[i].getFoodType();
        if (checkFood == 'UNKNOWN'){
            checkFood = ' Unknown (this POI does not serve food, or the food available is unknown)';
        }
        list +=  '' + result[i].getName() +
        ' at ' + result[i].getLocation() +
        ' is a POI of type ' +
        result[i].getType() + '\n' +
        ' -- POI summary with phone number: ' + result[i].toString() + '\n' +
        ' -- POI food type: ' + checkFood + '\n' ;
    } alert (list);
}, function (error) {alert(error)});

Represents a 2D spatial coordinate pair.

A PointFeature may be a city from a GeoBase data file, or a point feature from a custom dataset.

A sub-type enumeration representing various types of restaurant.

An enumeration of the various valid type descriptions for points of interest. These can be used for filtering the results of DataQuery invocations.

Represents a closed polygonal map feature such as a lake or national park. Not to be confused with a Geometry.Polygon, which is the physical shape of the Geometry object contained in the geometries array.

A class to contain a pair of x- and y- coordinates that represent the corners of a rectangle. Analogous to the Rectangle .NET class.

A wrapper class for containing data about a single street link.

Contains classes related to vehicle routing and getting driving directions.

A wrapper class to be filled server-side that represents an arrival movement.

A wrapper class to be filled server-side that represents an arrival event.

A wrapper class to be filled server-side that represents a departure event.

A wrapper class to be filled server-side that represents a departure movement.

A wrapper class to be filled server-side, representing a single instruction in a Routing.Route.

A representation of a driving route through a number of stops. This is a wrapper class to be filled server-side.

A base class, populated server-side, that represents an event that occurs en route -- such as a driving direction or movement.

A wrapper class to be filled server-side that represents a note attached to a direction.

A wrapper class to be filled server-side that represents a ferry movement.

A wrapper class to be filled server-side that represents an FF ramp movement.

A wrapper class to be filled server-side that represents a Routing.DrivingNote, denoting a street name change.

A wrapper class to be filled server-side that represents an FS ramp movement.

Describes a type of load

A wrapper class to be filled server-side that represents a driving direction instructing the driver to turn at an intersection.

A wrapper class to be filled server-side that represents a Routing.DrivingEvent that happens during a movement.

A wrapper class to be filled server-side that represents a Routing.DrivingNote, denoting a street name change.

A wrapper class to be filled server-side that represents a note attached to a direction.

A base class representing a movement event along a freeway ramp.

A wrapper class to be filled server-side that represents a roundabout movement.

A class for constructing point-to-point directions and optimizing multi-stop routes.

var LatLon = Telogis.GeoBase.LatLon;
var RouteStop = Telogis.GeoBase.Routing.RouteStop;

// Create three route stops
var RouteStop1 = new RouteStop(new LatLon(33.587512,-117.741400));
var RouteStop2 = new RouteStop(new LatLon(33.553872,-117.728464));
var RouteStop3 = new RouteStop(new LatLon(33.537614,-117.687859));

// Create an array of route stops
var StopsArray = [RouteStop1, RouteStop2, RouteStop3];

// Specify a routing strategy --  RoutingStrategyFastest is the default
var RoutingStrategyFastest = new Telogis.GeoBase.Routing.RoutingStrategyFastest();

// Create a new route
var myRoute = new Telogis.GeoBase.Routing.Route({
        stops: StopsArray,
        strategy: RoutingStrategyFastest
});

// Was the route created? Check that there are three stops...

// document.onclick = myTestFunction;
function myTestFunction() {
        alert ('There are ' + myRoute.getStopCount() + ' stops in this route.');
};

A wrapper class for containing a route stop in a format understood by the server. In all other situations, LatLons should be used instead, and since the conversion between the two is handled by the Routing.Route class, this class need not be used directly.

var myRouteStop = new Telogis.GeoBase.Routing.RouteStop(new Telogis.GeoBase.LatLon(33.612914,-117.745395));

A class used to determine the speed profile (the permitted speed of travel), based on either speed category or a custom speed profile generated using an array of 48 speed values (one for each functional class and speed combination). This array is constructed using six consecutive blocks of eight elements. Each block represents a functional class (1-6), the first block represents functional class 1, the second block functional class 2, etc. The first element in the each block corresponds to speed category 1, the second element speed category 2, etc. These profiles are used when routing, and applied as a Routing.RoutingStrategy.

var speed = Telogis.GeoBase.SpeedUnit.MilesPerHour;
var strategy = new Telogis.GeoBase.Routing.RoutingStrategyFastest();
var profile = new Telogis.GeoBase.Routing.RoutingProfile();
// For every speed category (1-8)
for (speedCat = 1; speedCat <9; ++speedCat) {
    // And every functional class (1-6)
    for (var funcClass = 1; funcClass < 7; ++funcClass) {
    // Set the profile speed to 10mph
    profile.setSpeed(speedCat, funcClass, 10, speed);
    }
}
// Apply the routing profile to the strategy in the UK
strategy.setProfile("UK", profile);

Describes a set of constraints to which the routing engine should adhere when calculating a route.

// Create a strategy that allows u-turns, road crossings and travel along toll roads.
var myStrategy = new Telogis.GeoBase.Routing.RoutingStrategy({
    allowUTurns: true,
    extraProcessingRatio: 1,
    roadCrossingBehavior: 'Telogis.GeoBase.Routing.RoadCrossingBehavior.ALLOWED',
    // ALLOWED is the default. Alternative options are 'DISCOURAGED' and 'FORBIDDEN'
    useTollRoads: true
});

// Create a route
var myRoute = new Telogis.GeoBase.Routing.Route();

// Apply the strategy to the route
myRoute.setStrategy(myStrategy);

A type of Routing.RoutingStrategy that specifies a custom callback on the server to favor faster routes.

var fastest_strategy = new Telogis.GeoBase.Routing.RoutingStrategyFastest();
route.setStrategy(fastest_strategy);

A type of Routing.RoutingStrategy that specifies a custom callback on the server to favor shorter routes.

var shortest_strategy = new Telogis.GeoBase.Routing.RoutingStrategyShortest();
route.setStrategy(shortest_strategy);

A wrapper class to be filled server-side that represents an SF ramp movement.

A wrapper class to be filled server-side that represents a split movement.

A wrapper class to be filled server-side that represents a Routing.DrivingNote, denoting a street name change.

A wrapper class to be filled server-side that represents a Routing.DrivingNote, denoting a street name change.

A wrapper class to be filled server-side that represents a Routing.DrivingNote, denoting a street name change.

A wrapper class to be filled server-side that represents a turn movement.

Used to describe a vehicle's specifications.

// Create a new vehicle specifications object
var VehSpec = new Telogis.GeoBase.Routing.VehicleSpec();

// Set some vehicle properties (weight, height, length, width etc.)
VehSpec.GrossWeight_kg = 30000; // 30 tonnes
VehSpec.Height_cm = 410; // 4.1 meters high
VehSpec.Length_cm = 1800; // 18 meters long
VehSpec.Width_cm = 260; // 2.6 meters wide

// Apply the VehicleSpec to a route --
// Routes will now be generated that are safe for a vehicle with
// the described specifications. For example, avoiding bridges
// that are too low or too narrow, or that cannot support the
// vehicle's weight
myRoute.setVehicleSpec(VehSpec);

Describes a type of vehicle. When applied to a route as a vehicle specification, routes suitable for the specified vehicle type will be generated. For example, Emergency vehicles will be routed using emergency vehicle lanes and directions; and Taxi, CarPool and Bus vehicle types will be routed along suitable restricted traffic lanes where available.

// Create a new vehicle specifications object
var VehSpec = new Telogis.GeoBase.Routing.VehicleSpec();

// Set the vehicle type (tractor semi trailer)
VehSpec.VehicleType = Telogis.GeoBase.Routing.VehicleType.TractorSemiTrailer;

// Apply the VehicleSpec to a route --
// Routes will now be generated that are legal for the vehicle type
myRoute.setVehicleSpec(VehSpec);

Describes a load carried by a vehicle. Hazardous loads should be categorized using a HAZMAT category.

A wrapper class for containing a waypoint in a format understood by the server. In all other situations, LatLons should be used instead, and since the conversion between the two is handled by the Routing.Route class, this class need not be used directly.

A wrapper class to be filled server-side that represents a waypoint event.

Represents the 2D spatial dimensions of an object.

An abstract base class defining functionality common to all types of more specific skin. Primarily, it will manage loading the skin's constituent images.

A collection of values representing the various speed units that can be used with MathUtil. While each of these values should be used primarily as a code to represent its corresponding unit, it is also the string abbreviation of the unit and can thus be used for labelling.

Represents a physical street.

A collection of values representing the various time units that can be used with MathUtil. While each of these values should be used primarily as a code to represent its corresponding unit, it is also the string abbreviation of the unit and can thus be used for labelling.

Contains classes and functions for dealing with image transitions.

Provides a simple way to handle transitions.

A class for wrapping together all the different factors involved in performing a transition. Once constructed, it can be passed to a Transitions.TimeLine for execution.

Contains all widgets and widget-related functions for the JavaScript GeoStream API. This also acts as a global hash for all instantiated derivations of MapLayers.AbstractLayer, so that if a reference is not kept to such an object, it can be accessed like so:

var Widgets = Telogis.GeoBase.Widgets;
var Map     = Telogis.GeoBase.Widgets.Map;

new Map ({id: 'main_map'});
var map = Widgets ['main_map'];

A class from which elements such as maps and map controls are derived.

A map widget designed to contain others, such as a slider and scale, to neatly dock them against one edge of the map.

A near-trivial skin wrapper describing the customizable appearance of a Widgets.Dock. Since such a dock is skinned merely by an unsized background image and a border style, it is not necessary to wait for this skin to load before use.

Represents a displayed map on the page -- the main component of the GeoStream mapping framework. A MapLayers.TileLayer is implicitly created with the map; other layers can be constructed later. All layers belonging to the map can be accessed by subscripting the map variable with their IDs, like so:

var Map         = Telogis.GeoBase.Widgets.Map;
var ObjectLayer = Telogis.GeoBase.MapLayers.ObjectLayer;

var map = new Map ({id: 'main_map'});
new ObjectLayer ({id: 'pin_layer', map: map});

var layer = map ['pin_layer'];

An abstract skinnable map widget.

A widget to show the distances represented by a map.

A simple class that combines all the information describing the appearance of a map-scale widget, and can be used to theme map-scales reasonably painlessly.

A skinnable widget used to control zoom levels on a map.

A small class collecting all the customizable appearance information for a zoom / slider map control and presenting some simple methods to help apply it.

A class that provides a wrapper around all of the basic required XML functionality to abstract the differences in implementations between web browsers.