RubyGems - simpletool - Versions diffs - 0.0.3 → 0.0.4 - Mend

simpletool 0.0.3 → 0.0.4

Files changed (1702) hide show

data/lib/support/phpmyadmin/phpmyadmin/js/openlayers/src/openlayers/lib/OpenLayers/Map.js DELETED Viewed

@@ -1,2417 +0,0 @@
-/* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for
- * full list of contributors). Published under the Clear BSD license.
- * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
- * full text of the license. */
-/**
- * @requires OpenLayers/Util.js
- * @requires OpenLayers/Events.js
- * @requires OpenLayers/Tween.js
- * @requires OpenLayers/Console.js
- */
-/**
- * Class: OpenLayers.Map
- * Instances of OpenLayers.Map are interactive maps embedded in a web page.
- * Create a new map with the <OpenLayers.Map> constructor.
- *
- * On their own maps do not provide much functionality.  To extend a map
- * it's necessary to add controls (<OpenLayers.Control>) and
- * layers (<OpenLayers.Layer>) to the map.
- */
-OpenLayers.Map = OpenLayers.Class({
-    /**
-     * Constant: Z_INDEX_BASE
-     * {Object} Base z-indexes for different classes of thing
-     */
-    Z_INDEX_BASE: {
-        BaseLayer: 100,
-        Overlay: 325,
-        Feature: 725,
-        Popup: 750,
-        Control: 1000
-    },
-    /**
-     * Constant: EVENT_TYPES
-     * {Array(String)} Supported application event types.  Register a listener
-     *     for a particular event with the following syntax:
-     * (code)
-     * map.events.register(type, obj, listener);
-     * (end)
-     *
-     * Listeners will be called with a reference to an event object.  The
-     *     properties of this event depends on exactly what happened.
-     *
-     * All event objects have at least the following properties:
-     *  - *object* {Object} A reference to map.events.object.
-     *  - *element* {DOMElement} A reference to map.events.element.
-     *
-     * Browser events have the following additional properties:
-     *  - *xy* {<OpenLayers.Pixel>} The pixel location of the event (relative
-     *      to the the map viewport).
-     *  - other properties that come with browser events
-     *
-     * Supported map event types:
-     *  - *preaddlayer* triggered before a layer has been added.  The event
-     *      object will include a *layer* property that references the layer
-     *      to be added.
-     *  - *addlayer* triggered after a layer has been added.  The event object
-     *      will include a *layer* property that references the added layer.
-     *  - *removelayer* triggered after a layer has been removed.  The event
-     *      object will include a *layer* property that references the removed
-     *      layer.
-     *  - *changelayer* triggered after a layer name change, order change,
-     *      opacity change, params change or visibility change
-     *      (due to resolution thresholds). Listeners will receive an event
-     *      object with *layer* and *property* properties. The *layer*
-     *      property will be a reference to the changed layer.
-     *      The *property* property will be a key to the
-     *      changed property (name, order, opacity, params or visibility).
-     *  - *movestart* triggered after the start of a drag, pan, or zoom
-     *  - *move* triggered after each drag, pan, or zoom
-     *  - *moveend* triggered after a drag, pan, or zoom completes
-     *  - *zoomend* triggered after a zoom completes
-     *  - *mouseover* triggered after mouseover the map
-     *  - *mouseout* triggered after mouseout the map
-     *  - *mousemove* triggered after mousemove the map
-     *  - *changebaselayer* triggered after the base layer changes
-     */
-    EVENT_TYPES: [
-        "preaddlayer", "addlayer", "removelayer", "changelayer", "movestart",
-        "move", "moveend", "zoomend", "popupopen", "popupclose",
-        "addmarker", "removemarker", "clearmarkers", "mouseover",
-        "mouseout", "mousemove", "dragstart", "drag", "dragend",
-        "changebaselayer"],
-    /**
-     * Property: id
-     * {String} Unique identifier for the map
-     */
-    id: null,
-    /**
-     * Property: fractionalZoom
-     * {Boolean} For a base layer that supports it, allow the map resolution
-     *     to be set to a value between one of the values in the resolutions
-     *     array.  Default is false.
-     *
-     * When fractionalZoom is set to true, it is possible to zoom to
-     *     an arbitrary extent.  This requires a base layer from a source
-     *     that supports requests for arbitrary extents (i.e. not cached
-     *     tiles on a regular lattice).  This means that fractionalZoom
-     *     will not work with commercial layers (Google, Yahoo, VE), layers
-     *     using TileCache, or any other pre-cached data sources.
-     *
-     * If you are using fractionalZoom, then you should also use
-     *     <getResolutionForZoom> instead of layer.resolutions[zoom] as the
-     *     former works for non-integer zoom levels.
-     */
-    fractionalZoom: false,
-    /**
-     * APIProperty: events
-     * {<OpenLayers.Events>} An events object that handles all
-     *                       events on the map
-     */
-    events: null,
-    /**
-     * APIProperty: allOverlays
-     * {Boolean} Allow the map to function with "overlays" only.  Defaults to
-     *     false.  If true, the lowest layer in the draw order will act as
-     *     the base layer.  In addition, if set to true, all layers will
-     *     have isBaseLayer set to false when they are added to the map.
-     *
-     * Note:
-     * If you set map.allOverlays to true, then you *cannot* use
-     *     map.setBaseLayer or layer.setIsBaseLayer.  With allOverlays true,
-     *     the lowest layer in the draw layer is the base layer.  So, to change
-     *     the base layer, use <setLayerIndex> or <raiseLayer> to set the layer
-     *     index to 0.
-     */
-    allOverlays: false,
-    /**
-     * APIProperty: div
-     * {DOMElement|String} The element that contains the map (or an id for
-     *     that element).  If the <OpenLayers.Map> constructor is called
-     *     with two arguments, this should be provided as the first argument.
-     *     Alternatively, the map constructor can be called with the options
-     *     object as the only argument.  In this case (one argument), a
-     *     div property may or may not be provided.  If the div property
-     *     is not provided, the map can be rendered to a container later
-     *     using the <render> method.
-     *
-     * Note:
-     * If you are calling <render> after map construction, do not use
-     *     <maxResolution>  auto.  Instead, divide your <maxExtent> by your
-     *     maximum expected dimension.
-     */
-    div: null,
-    /**
-     * Property: dragging
-     * {Boolean} The map is currently being dragged.
-     */
-    dragging: false,
-    /**
-     * Property: size
-     * {<OpenLayers.Size>} Size of the main div (this.div)
-     */
-    size: null,
-    /**
-     * Property: viewPortDiv
-     * {HTMLDivElement} The element that represents the map viewport
-     */
-    viewPortDiv: null,
-    /**
-     * Property: layerContainerOrigin
-     * {<OpenLayers.LonLat>} The lonlat at which the later container was
-     *                       re-initialized (on-zoom)
-     */
-    layerContainerOrigin: null,
-    /**
-     * Property: layerContainerDiv
-     * {HTMLDivElement} The element that contains the layers.
-     */
-    layerContainerDiv: null,
-    /**
-     * APIProperty: layers
-     * {Array(<OpenLayers.Layer>)} Ordered list of layers in the map
-     */
-    layers: null,
-    /**
-     * Property: controls
-     * {Array(<OpenLayers.Control>)} List of controls associated with the map.
-     *
-     * If not provided in the map options at construction, the map will
-     *     be given the following controls by default:
-     *  - <OpenLayers.Control.Navigation>
-     *  - <OpenLayers.Control.PanZoom>
-     *  - <OpenLayers.Control.ArgParser>
-     *  - <OpenLayers.Control.Attribution>
-     */
-    controls: null,
-    /**
-     * Property: popups
-     * {Array(<OpenLayers.Popup>)} List of popups associated with the map
-     */
-    popups: null,
-    /**
-     * APIProperty: baseLayer
-     * {<OpenLayers.Layer>} The currently selected base layer.  This determines
-     * min/max zoom level, projection, etc.
-     */
-    baseLayer: null,
-    /**
-     * Property: center
-     * {<OpenLayers.LonLat>} The current center of the map
-     */
-    center: null,
-    /**
-     * Property: resolution
-     * {Float} The resolution of the map.
-     */
-    resolution: null,
-    /**
-     * Property: zoom
-     * {Integer} The current zoom level of the map
-     */
-    zoom: 0,
-    /**
-     * Property: panRatio
-     * {Float} The ratio of the current extent within
-     *         which panning will tween.
-     */
-    panRatio: 1.5,
-    /**
-     * Property: viewRequestID
-     * {String} Used to store a unique identifier that changes when the map
-     *          view changes. viewRequestID should be used when adding data
-     *          asynchronously to the map: viewRequestID is incremented when
-     *          you initiate your request (right now during changing of
-     *          baselayers and changing of zooms). It is stored here in the
-     *          map and also in the data that will be coming back
-     *          asynchronously. Before displaying this data on request
-     *          completion, we check that the viewRequestID of the data is
-     *          still the same as that of the map. Fix for #480
-     */
-    viewRequestID: 0,
-  // Options
-    /**
-     * APIProperty: tileSize
-     * {<OpenLayers.Size>} Set in the map options to override the default tile
-     *                     size for this map.
-     */
-    tileSize: null,
-    /**
-     * APIProperty: projection
-     * {String} Set in the map options to override the default projection
-     *          string this map - also set maxExtent, maxResolution, and
-     *          units if appropriate.  Default is "EPSG:4326".
-     */
-    projection: "EPSG:4326",
-    /**
-     * APIProperty: units
-     * {String} The map units.  Defaults to 'degrees'.  Possible values are
-     *          'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'.
-     */
-    units: 'degrees',
-    /**
-     * APIProperty: resolutions
-     * {Array(Float)} A list of map resolutions (map units per pixel) in
-     *     descending order.  If this is not set in the layer constructor, it
-     *     will be set based on other resolution related properties
-     *     (maxExtent, maxResolution, maxScale, etc.).
-     */
-    resolutions: null,
-    /**
-     * APIProperty: maxResolution
-     * {Float} Default max is 360 deg / 256 px, which corresponds to
-     *          zoom level 0 on gmaps.  Specify a different value in the map
-     *          options if you are not using a geographic projection and
-     *          displaying the whole world.
-     */
-    maxResolution: 1.40625,
-    /**
-     * APIProperty: minResolution
-     * {Float}
-     */
-    minResolution: null,
-    /**
-     * APIProperty: maxScale
-     * {Float}
-     */
-    maxScale: null,
-    /**
-     * APIProperty: minScale
-     * {Float}
-     */
-    minScale: null,
-    /**
-     * APIProperty: maxExtent
-     * {<OpenLayers.Bounds>} The maximum extent for the map.  Defaults to the
-     *                       whole world in decimal degrees
-     *                       (-180, -90, 180, 90).  Specify a different
-     *                        extent in the map options if you are not using a
-     *                        geographic projection and displaying the whole
-     *                        world.
-     */
-    maxExtent: null,
-    /**
-     * APIProperty: minExtent
-     * {<OpenLayers.Bounds>}
-     */
-    minExtent: null,
-    /**
-     * APIProperty: restrictedExtent
-     * {<OpenLayers.Bounds>} Limit map navigation to this extent where possible.
-     *     If a non-null restrictedExtent is set, panning will be restricted
-     *     to the given bounds.  In addition, zooming to a resolution that
-     *     displays more than the restricted extent will center the map
-     *     on the restricted extent.  If you wish to limit the zoom level
-     *     or resolution, use maxResolution.
-     */
-    restrictedExtent: null,
-    /**
-     * APIProperty: numZoomLevels
-     * {Integer} Number of zoom levels for the map.  Defaults to 16.  Set a
-     *           different value in the map options if needed.
-     */
-    numZoomLevels: 16,
-    /**
-     * APIProperty: theme
-     * {String} Relative path to a CSS file from which to load theme styles.
-     *          Specify null in the map options (e.g. {theme: null}) if you
-     *          want to get cascading style declarations - by putting links to
-     *          stylesheets or style declarations directly in your page.
-     */
-    theme: null,
-    /**
-     * APIProperty: displayProjection
-     * {<OpenLayers.Projection>} Requires proj4js support.Projection used by
-     *     several controls to display data to user. If this property is set,
-     *     it will be set on any control which has a null displayProjection
-     *     property at the time the control is added to the map.
-     */
-    displayProjection: null,
-    /**
-     * APIProperty: fallThrough
-     * {Boolean} Should OpenLayers allow events on the map to fall through to
-     *           other elements on the page, or should it swallow them? (#457)
-     *           Default is to fall through.
-     */
-    fallThrough: true,
-    /**
-     * Property: panTween
-     * {OpenLayers.Tween} Animated panning tween object, see panTo()
-     */
-    panTween: null,
-    /**
-     * APIProperty: eventListeners
-     * {Object} If set as an option at construction, the eventListeners
-     *     object will be registered with <OpenLayers.Events.on>.  Object
-     *     structure must be a listeners object as shown in the example for
-     *     the events.on method.
-     */
-    eventListeners: null,
-    /**
-     * APIProperty: panMethod
-     * {Function} The Easing function to be used for tweening.  Default is
-     * OpenLayers.Easing.Expo.easeOut. Setting this to 'null' turns off
-     * animated panning.
-     */
-    panMethod: OpenLayers.Easing.Expo.easeOut,
-    /**
-     * Property: panDuration
-     * {Integer} The number of steps to be passed to the
-     * OpenLayers.Tween.start() method when the map is
-     * panned.
-     * Default is 50.
-     */
-    panDuration: 50,
-    /**
-     * Property: paddingForPopups
-     * {<OpenLayers.Bounds>} Outside margin of the popup. Used to prevent
-     *     the popup from getting too close to the map border.
-     */
-    paddingForPopups : null,
-    /**
-     * Constructor: OpenLayers.Map
-     * Constructor for a new OpenLayers.Map instance.  There are two possible
-     *     ways to call the map constructor.  See the examples below.
-     *
-     * Parameters:
-     * div - {DOMElement|String}  The element or id of an element in your page
-     *     that will contain the map.  May be omitted if the <div> option is
-     *     provided or if you intend to call the <render> method later.
-     * options - {Object} Optional object with properties to tag onto the map.
-     *
-     * Examples (method one):
-     * (code)
-     * // create a map with default options in an element with the id "map1"
-     * var map = new OpenLayers.Map("map1");
-     *
-     * // create a map with non-default options in an element with id "map2"
-     * var options = {
-     *     maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000),
-     *     maxResolution: 156543,
-     *     units: 'm',
-     *     projection: "EPSG:41001"
-     * };
-     * var map = new OpenLayers.Map("map2", options);
-     * (end)
-     *
-     * Examples (method two - single argument):
-     * (code)
-     * // create a map with non-default options
-     * var map = new OpenLayers.Map({
-     *     div: "map_id",
-     *     maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000),
-     *     maxResolution: 156543,
-     *     units: 'm',
-     *     projection: "EPSG:41001"
-     * });
-     *
-     * // create a map without a reference to a container - call render later
-     * var map = new OpenLayers.Map({
-     *     maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000),
-     *     maxResolution: 156543,
-     *     units: 'm',
-     *     projection: "EPSG:41001"
-     * });
-     */
-    initialize: function (div, options) {
-        // If only one argument is provided, check if it is an object.
-        if(arguments.length === 1 && typeof div === "object") {
-            options = div;
-            div = options && options.div;
-        }
-        // Simple-type defaults are set in class definition.
-        //  Now set complex-type defaults
-        this.tileSize = new OpenLayers.Size(OpenLayers.Map.TILE_WIDTH,
-                                            OpenLayers.Map.TILE_HEIGHT);
-        this.maxExtent = new OpenLayers.Bounds(-180, -90, 180, 90);
-        this.paddingForPopups = new OpenLayers.Bounds(15, 15, 15, 15);
-        this.theme = OpenLayers._getScriptLocation() +
-                             'theme/default/style.css';
-        // now override default options
-        OpenLayers.Util.extend(this, options);
-        // initialize layers array
-        this.layers = [];
-        this.id = OpenLayers.Util.createUniqueID("OpenLayers.Map_");
-        this.div = OpenLayers.Util.getElement(div);
-        if(!this.div) {
-            this.div = document.createElement("div");
-            this.div.style.height = "1px";
-            this.div.style.width = "1px";
-        }
-        OpenLayers.Element.addClass(this.div, 'olMap');
-        // the viewPortDiv is the outermost div we modify
-        var id = this.id + "_OpenLayers_ViewPort";
-        this.viewPortDiv = OpenLayers.Util.createDiv(id, null, null, null,
-                                                     "relative", null,
-                                                     "hidden");
-        this.viewPortDiv.style.width = "100%";
-        this.viewPortDiv.style.height = "100%";
-        this.viewPortDiv.className = "olMapViewport";
-        this.div.appendChild(this.viewPortDiv);
-        // the layerContainerDiv is the one that holds all the layers
-        id = this.id + "_OpenLayers_Container";
-        this.layerContainerDiv = OpenLayers.Util.createDiv(id);
-        this.layerContainerDiv.style.zIndex=this.Z_INDEX_BASE['Popup']-1;
-        this.viewPortDiv.appendChild(this.layerContainerDiv);
-        this.events = new OpenLayers.Events(this,
-                                            this.div,
-                                            this.EVENT_TYPES,
-                                            this.fallThrough,
-                                            {includeXY: true});
-        this.updateSize();
-        if(this.eventListeners instanceof Object) {
-            this.events.on(this.eventListeners);
-        }
-        // update the map size and location before the map moves
-        this.events.register("movestart", this, this.updateSize);
-        // Because Mozilla does not support the "resize" event for elements
-        // other than "window", we need to put a hack here.
-        if (OpenLayers.String.contains(navigator.appName, "Microsoft")) {
-            // If IE, register the resize on the div
-            this.events.register("resize", this, this.updateSize);
-        } else {
-            // Else updateSize on catching the window's resize
-            //  Note that this is ok, as updateSize() does nothing if the
-            //  map's size has not actually changed.
-            this.updateSizeDestroy = OpenLayers.Function.bind(this.updateSize,
-                this);
-            OpenLayers.Event.observe(window, 'resize',
-                            this.updateSizeDestroy);
-        }
-        // only append link stylesheet if the theme property is set
-        if(this.theme) {
-            // check existing links for equivalent url
-            var addNode = true;
-            var nodes = document.getElementsByTagName('link');
-            for(var i=0, len=nodes.length; i<len; ++i) {
-                if(OpenLayers.Util.isEquivalentUrl(nodes.item(i).href,
-                                                   this.theme)) {
-                    addNode = false;
-                    break;
-                }
-            }
-            // only add a new node if one with an equivalent url hasn't already
-            // been added
-            if(addNode) {
-                var cssNode = document.createElement('link');
-                cssNode.setAttribute('rel', 'stylesheet');
-                cssNode.setAttribute('type', 'text/css');
-                cssNode.setAttribute('href', this.theme);
-                document.getElementsByTagName('head')[0].appendChild(cssNode);
-            }
-        }
-        if (this.controls == null) {
-            if (OpenLayers.Control != null) { // running full or lite?
-                this.controls = [ new OpenLayers.Control.Navigation(),
-                                  new OpenLayers.Control.PanZoom(),
-                                  new OpenLayers.Control.ArgParser(),
-                                  new OpenLayers.Control.Attribution()
-                                ];
-            } else {
-                this.controls = [];
-            }
-        }
-        for(var i=0, len=this.controls.length; i<len; i++) {
-            this.addControlToMap(this.controls[i]);
-        }
-        this.popups = [];
-        this.unloadDestroy = OpenLayers.Function.bind(this.destroy, this);
-        // always call map.destroy()
-        OpenLayers.Event.observe(window, 'unload', this.unloadDestroy);
-        // add any initial layers
-        if (options && options.layers) {
-            this.addLayers(options.layers);
-            // set center (and optionally zoom)
-            if (options.center) {
-                // zoom can be undefined here
-                this.setCenter(options.center, options.zoom);
-            }
-        }
-    },
-    /**
-     * APIMethod: render
-     * Render the map to a specified container.
-     *
-     * Parameters:
-     * div - {String|DOMElement} The container that the map should be rendered
-     *     to. If different than the current container, the map viewport
-     *     will be moved from the current to the new container.
-     */
-    render: function(div) {
-        this.div = OpenLayers.Util.getElement(div);
-        OpenLayers.Element.addClass(this.div, 'olMap');
-        this.events.attachToElement(this.div);
-        this.viewPortDiv.parentNode.removeChild(this.viewPortDiv);
-        this.div.appendChild(this.viewPortDiv);
-        this.updateSize();
-    },
-    /**
-     * Method: unloadDestroy
-     * Function that is called to destroy the map on page unload. stored here
-     *     so that if map is manually destroyed, we can unregister this.
-     */
-    unloadDestroy: null,
-    /**
-     * Method: updateSizeDestroy
-     * When the map is destroyed, we need to stop listening to updateSize
-     *    events: this method stores the function we need to unregister in
-     *    non-IE browsers.
-     */
-    updateSizeDestroy: null,
-    /**
-     * APIMethod: destroy
-     * Destroy this map
-     */
-    destroy:function() {
-        // if unloadDestroy is null, we've already been destroyed
-        if (!this.unloadDestroy) {
-            return false;
-        }
-        // make sure panning doesn't continue after destruction
-        if(this.panTween) {
-            this.panTween.stop();
-            this.panTween = null;
-        }
-        // map has been destroyed. dont do it again!
-        OpenLayers.Event.stopObserving(window, 'unload', this.unloadDestroy);
-        this.unloadDestroy = null;
-        if (this.updateSizeDestroy) {
-            OpenLayers.Event.stopObserving(window, 'resize',
-                                           this.updateSizeDestroy);
-        } else {
-            this.events.unregister("resize", this, this.updateSize);
-        }
-        this.paddingForPopups = null;
-        if (this.controls != null) {
-            for (var i = this.controls.length - 1; i>=0; --i) {
-                this.controls[i].destroy();
-            }
-            this.controls = null;
-        }
-        if (this.layers != null) {
-            for (var i = this.layers.length - 1; i>=0; --i) {
-                //pass 'false' to destroy so that map wont try to set a new
-                // baselayer after each baselayer is removed
-                this.layers[i].destroy(false);
-            }
-            this.layers = null;
-        }
-        if (this.viewPortDiv) {
-            this.div.removeChild(this.viewPortDiv);
-        }
-        this.viewPortDiv = null;
-        if(this.eventListeners) {
-            this.events.un(this.eventListeners);
-            this.eventListeners = null;
-        }
-        this.events.destroy();
-        this.events = null;
-    },
-    /**
-     * APIMethod: setOptions
-     * Change the map options
-     *
-     * Parameters:
-     * options - {Object} Hashtable of options to tag to the map
-     */
-    setOptions: function(options) {
-        OpenLayers.Util.extend(this, options);
-    },
-    /**
-     * APIMethod: getTileSize
-     * Get the tile size for the map
-     *
-     * Returns:
-     * {<OpenLayers.Size>}
-     */
-     getTileSize: function() {
-         return this.tileSize;
-     },
-    /**
-     * APIMethod: getBy
-     * Get a list of objects given a property and a match item.
-     *
-     * Parameters:
-     * array - {String} A property on the map whose value is an array.
-     * property - {String} A property on each item of the given array.
-     * match - {String | Object} A string to match.  Can also be a regular
-     *     expression literal or object.  In addition, it can be any object
-     *     with a method named test.  For reqular expressions or other, if
-     *     match.test(map[array][i][property]) evaluates to true, the item will
-     *     be included in the array returned.  If no items are found, an empty
-     *     array is returned.
-     *
-     * Returns:
-     * {Array} An array of items where the given property matches the given
-     *     criteria.
-     */
-    getBy: function(array, property, match) {
-        var test = (typeof match.test == "function");
-        var found = OpenLayers.Array.filter(this[array], function(item) {
-            return item[property] == match || (test && match.test(item[property]));
-        });
-        return found;
-    },
-    /**
-     * APIMethod: getLayersBy
-     * Get a list of layers with properties matching the given criteria.
-     *
-     * Parameter:
-     * property - {String} A layer property to be matched.
-     * match - {String | Object} A string to match.  Can also be a regular
-     *     expression literal or object.  In addition, it can be any object
-     *     with a method named test.  For reqular expressions or other, if
-     *     match.test(layer[property]) evaluates to true, the layer will be
-     *     included in the array returned.  If no layers are found, an empty
-     *     array is returned.
-     *
-     * Returns:
-     * {Array(<OpenLayers.Layer>)} A list of layers matching the given criteria.
-     *     An empty array is returned if no matches are found.
-     */
-    getLayersBy: function(property, match) {
-        return this.getBy("layers", property, match);
-    },
-    /**
-     * APIMethod: getLayersByName
-     * Get a list of layers with names matching the given name.
-     *
-     * Parameter:
-     * match - {String | Object} A layer name.  The name can also be a regular
-     *     expression literal or object.  In addition, it can be any object
-     *     with a method named test.  For reqular expressions or other, if
-     *     name.test(layer.name) evaluates to true, the layer will be included
-     *     in the list of layers returned.  If no layers are found, an empty
-     *     array is returned.
-     *
-     * Returns:
-     * {Array(<OpenLayers.Layer>)} A list of layers matching the given name.
-     *     An empty array is returned if no matches are found.
-     */
-    getLayersByName: function(match) {
-        return this.getLayersBy("name", match);
-    },
-    /**
-     * APIMethod: getLayersByClass
-     * Get a list of layers of a given class (CLASS_NAME).
-     *
-     * Parameter:
-     * match - {String | Object} A layer class name.  The match can also be a
-     *     regular expression literal or object.  In addition, it can be any
-     *     object with a method named test.  For reqular expressions or other,
-     *     if type.test(layer.CLASS_NAME) evaluates to true, the layer will
-     *     be included in the list of layers returned.  If no layers are
-     *     found, an empty array is returned.
-     *
-     * Returns:
-     * {Array(<OpenLayers.Layer>)} A list of layers matching the given class.
-     *     An empty array is returned if no matches are found.
-     */
-    getLayersByClass: function(match) {
-        return this.getLayersBy("CLASS_NAME", match);
-    },
-    /**
-     * APIMethod: getControlsBy
-     * Get a list of controls with properties matching the given criteria.
-     *
-     * Parameter:
-     * property - {String} A control property to be matched.
-     * match - {String | Object} A string to match.  Can also be a regular
-     *     expression literal or object.  In addition, it can be any object
-     *     with a method named test.  For reqular expressions or other, if
-     *     match.test(layer[property]) evaluates to true, the layer will be
-     *     included in the array returned.  If no layers are found, an empty
-     *     array is returned.
-     *
-     * Returns:
-     * {Array(<OpenLayers.Control>)} A list of controls matching the given
-     *     criteria.  An empty array is returned if no matches are found.
-     */
-    getControlsBy: function(property, match) {
-        return this.getBy("controls", property, match);
-    },
-    /**
-     * APIMethod: getControlsByClass
-     * Get a list of controls of a given class (CLASS_NAME).
-     *
-     * Parameter:
-     * match - {String | Object} A control class name.  The match can also be a
-     *     regular expression literal or object.  In addition, it can be any
-     *     object with a method named test.  For reqular expressions or other,
-     *     if type.test(control.CLASS_NAME) evaluates to true, the control will
-     *     be included in the list of controls returned.  If no controls are
-     *     found, an empty array is returned.
-     *
-     * Returns:
-     * {Array(<OpenLayers.Control>)} A list of controls matching the given class.
-     *     An empty array is returned if no matches are found.
-     */
-    getControlsByClass: function(match) {
-        return this.getControlsBy("CLASS_NAME", match);
-    },
-  /********************************************************/
-  /*                                                      */
-  /*                  Layer Functions                     */
-  /*                                                      */
-  /*     The following functions deal with adding and     */
-  /*        removing Layers to and from the Map           */
-  /*                                                      */
-  /********************************************************/
-    /**
-     * APIMethod: getLayer
-     * Get a layer based on its id
-     *
-     * Parameter:
-     * id - {String} A layer id
-     *
-     * Returns:
-     * {<OpenLayers.Layer>} The Layer with the corresponding id from the map's
-     *                      layer collection, or null if not found.
-     */
-    getLayer: function(id) {
-        var foundLayer = null;
-        for (var i=0, len=this.layers.length; i<len; i++) {
-            var layer = this.layers[i];
-            if (layer.id == id) {
-                foundLayer = layer;
-                break;
-            }
-        }
-        return foundLayer;
-    },
-    /**
-    * Method: setLayerZIndex
-    *
-    * Parameters:
-    * layer - {<OpenLayers.Layer>}
-    * zIdx - {int}
-    */
-    setLayerZIndex: function (layer, zIdx) {
-        layer.setZIndex(
-            this.Z_INDEX_BASE[layer.isBaseLayer ? 'BaseLayer' : 'Overlay']
-            + zIdx * 5 );
-    },
-    /**
-     * Method: resetLayersZIndex
-     * Reset each layer's z-index based on layer's array index
-     */
-    resetLayersZIndex: function() {
-        for (var i=0, len=this.layers.length; i<len; i++) {
-            var layer = this.layers[i];
-            this.setLayerZIndex(layer, i);
-        }
-    },
-    /**
-    * APIMethod: addLayer
-    *
-    * Parameters:
-    * layer - {<OpenLayers.Layer>}
-    */
-    addLayer: function (layer) {
-        for(var i=0, len=this.layers.length; i <len; i++) {
-            if (this.layers[i] == layer) {
-                var msg = OpenLayers.i18n('layerAlreadyAdded',
-                                                      {'layerName':layer.name});
-                OpenLayers.Console.warn(msg);
-                return false;
-            }
-        }
-        if(this.allOverlays) {
-            layer.isBaseLayer = false;
-        }
-        if (this.events.triggerEvent("preaddlayer", {layer: layer}) === false) {
-            return;
-        }
-        layer.div.className = "olLayerDiv";
-        layer.div.style.overflow = "";
-        this.setLayerZIndex(layer, this.layers.length);
-        if (layer.isFixed) {
-            this.viewPortDiv.appendChild(layer.div);
-        } else {
-            this.layerContainerDiv.appendChild(layer.div);
-        }
-        this.layers.push(layer);
-        layer.setMap(this);
-        if (layer.isBaseLayer || (this.allOverlays && !this.baseLayer))  {
-            if (this.baseLayer == null) {
-                // set the first baselaye we add as the baselayer
-                this.setBaseLayer(layer);
-            } else {
-                layer.setVisibility(false);
-            }
-        } else {
-            layer.redraw();
-        }
-        this.events.triggerEvent("addlayer", {layer: layer});
-        layer.afterAdd();
-    },
-    /**
-    * APIMethod: addLayers
-    *
-    * Parameters:
-    * layers - {Array(<OpenLayers.Layer>)}
-    */
-    addLayers: function (layers) {
-        for (var i=0, len=layers.length; i<len; i++) {
-            this.addLayer(layers[i]);
-        }
-    },
-    /**
-     * APIMethod: removeLayer
-     * Removes a layer from the map by removing its visual element (the
-     *   layer.div property), then removing it from the map's internal list
-     *   of layers, setting the layer's map property to null.
-     *
-     *   a "removelayer" event is triggered.
-     *
-     *   very worthy of mention is that simply removing a layer from a map
-     *   will not cause the removal of any popups which may have been created
-     *   by the layer. this is due to the fact that it was decided at some
-     *   point that popups would not belong to layers. thus there is no way
-     *   for us to know here to which layer the popup belongs.
-     *
-     *     A simple solution to this is simply to call destroy() on the layer.
-     *     the default OpenLayers.Layer class's destroy() function
-     *     automatically takes care to remove itself from whatever map it has
-     *     been attached to.
-     *
-     *     The correct solution is for the layer itself to register an
-     *     event-handler on "removelayer" and when it is called, if it
-     *     recognizes itself as the layer being removed, then it cycles through
-     *     its own personal list of popups, removing them from the map.
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer>}
-     * setNewBaseLayer - {Boolean} Default is true
-     */
-    removeLayer: function(layer, setNewBaseLayer) {
-        if (setNewBaseLayer == null) {
-            setNewBaseLayer = true;
-        }
-        if (layer.isFixed) {
-            this.viewPortDiv.removeChild(layer.div);
-        } else {
-            this.layerContainerDiv.removeChild(layer.div);
-        }
-        OpenLayers.Util.removeItem(this.layers, layer);
-        layer.removeMap(this);
-        layer.map = null;
-        // if we removed the base layer, need to set a new one
-        if(this.baseLayer == layer) {
-            this.baseLayer = null;
-            if(setNewBaseLayer) {
-                for(var i=0, len=this.layers.length; i<len; i++) {
-                    var iLayer = this.layers[i];
-                    if (iLayer.isBaseLayer || this.allOverlays) {
-                        this.setBaseLayer(iLayer);
-                        break;
-                    }
-                }
-            }
-        }
-        this.resetLayersZIndex();
-        this.events.triggerEvent("removelayer", {layer: layer});
-    },
-    /**
-     * APIMethod: getNumLayers
-     *
-     * Returns:
-     * {Int} The number of layers attached to the map.
-     */
-    getNumLayers: function () {
-        return this.layers.length;
-    },
-    /**
-     * APIMethod: getLayerIndex
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer>}
-     *
-     * Returns:
-     * {Integer} The current (zero-based) index of the given layer in the map's
-     *           layer stack. Returns -1 if the layer isn't on the map.
-     */
-    getLayerIndex: function (layer) {
-        return OpenLayers.Util.indexOf(this.layers, layer);
-    },
-    /**
-     * APIMethod: setLayerIndex
-     * Move the given layer to the specified (zero-based) index in the layer
-     *     list, changing its z-index in the map display. Use
-     *     map.getLayerIndex() to find out the current index of a layer. Note
-     *     that this cannot (or at least should not) be effectively used to
-     *     raise base layers above overlays.
-     *
-     * Parameters:
-     * layer - {<OpenLayers.Layer>}
-     * idx - {int}
-     */
-    setLayerIndex: function (layer, idx) {
-        var base = this.getLayerIndex(layer);
-        if (idx < 0) {
-            idx = 0;
-        } else if (idx > this.layers.length) {
-            idx = this.layers.length;
-        }
-        if (base != idx) {
-            this.layers.splice(base, 1);
-            this.layers.splice(idx, 0, layer);
-            for (var i=0, len=this.layers.length; i<len; i++) {
-                this.setLayerZIndex(this.layers[i], i);
-            }
-            this.events.triggerEvent("changelayer", {
-                layer: layer, property: "order"
-            });
-            if(this.allOverlays) {
-                if(idx === 0) {
-                    this.setBaseLayer(layer);
-                } else if(this.baseLayer !== this.layers[0]) {
-                    this.setBaseLayer(this.layers[0]);
-                }
-            }
-        }
-    },
-    /**
-     * APIMethod: raiseLayer
-     * Change the index of the given layer by delta. If delta is positive,
-     *     the layer is moved up the map's layer stack; if delta is negative,
-     *     the layer is moved down.  Again, note that this cannot (or at least
-     *     should not) be effectively used to raise base layers above overlays.
-     *
-     * Paremeters:
-     * layer - {<OpenLayers.Layer>}
-     * delta - {int}
-     */
-    raiseLayer: function (layer, delta) {
-        var idx = this.getLayerIndex(layer) + delta;
-        this.setLayerIndex(layer, idx);
-    },
-    /**
-     * APIMethod: setBaseLayer
-     * Allows user to specify one of the currently-loaded layers as the Map's
-     *     new base layer.
-     *
-     * Parameters:
-     * newBaseLayer - {<OpenLayers.Layer>}
-     */
-    setBaseLayer: function(newBaseLayer) {
-        if (newBaseLayer != this.baseLayer) {
-            // ensure newBaseLayer is already loaded
-            if (OpenLayers.Util.indexOf(this.layers, newBaseLayer) != -1) {
-                // preserve center and scale when changing base layers
-                var center = this.getCenter();
-                var newResolution = OpenLayers.Util.getResolutionFromScale(
-                    this.getScale(), newBaseLayer.units
-                );
-                // make the old base layer invisible
-                if (this.baseLayer != null && !this.allOverlays) {
-                    this.baseLayer.setVisibility(false);
-                }
-                // set new baselayer
-                this.baseLayer = newBaseLayer;
-                // Increment viewRequestID since the baseLayer is
-                // changing. This is used by tiles to check if they should
-                // draw themselves.
-                this.viewRequestID++;
-                if(!this.allOverlays || this.baseLayer.visibility) {
-                    this.baseLayer.setVisibility(true);
-                }
-                // recenter the map
-                if (center != null) {
-                    // new zoom level derived from old scale
-                    var newZoom = this.getZoomForResolution(
-                        newResolution || this.resolution, true
-                    );
-                    // zoom and force zoom change
-                    this.setCenter(center, newZoom, false, true);
-                }
-                this.events.triggerEvent("changebaselayer", {
-                    layer: this.baseLayer
-                });
-            }
-        }
-    },
-  /********************************************************/
-  /*                                                      */
-  /*                 Control Functions                    */
-  /*                                                      */
-  /*     The following functions deal with adding and     */
-  /*        removing Controls to and from the Map         */
-  /*                                                      */
-  /********************************************************/
-    /**
-     * APIMethod: addControl
-     * Add the passed over control to the map. Optionally
-     *     position the control at the given pixel.
-     *
-     * Parameters:
-     * control - {<OpenLayers.Control>}
-     * px - {<OpenLayers.Pixel>}
-     */
-    addControl: function (control, px) {
-        this.controls.push(control);
-        this.addControlToMap(control, px);
-    },
-    /**
-     * APIMethod: addControls
-     * Add all of the passed over controls to the map.
-     *     You can pass over an optional second array
-     *     with pixel-objects to position the controls.
-     *     The indices of the two arrays should match and
-     *     you can add null as pixel for those controls
-     *     you want to be autopositioned.
-     *
-     * Parameters:
-     * controls - {Array(<OpenLayers.Control>)}
-     * pixels - {Array(<OpenLayers.Pixel>)}
-     */
-    addControls: function (controls, pixels) {
-        var pxs = (arguments.length === 1) ? [] : pixels;
-        for (var i=0, len=controls.length; i<len; i++) {
-            var ctrl = controls[i];
-            var px = (pxs[i]) ? pxs[i] : null;
-            this.addControl( ctrl, px );
-        }
-    },
-    /**
-     * Method: addControlToMap
-     *
-     * Parameters:
-     *
-     * control - {<OpenLayers.Control>}
-     * px - {<OpenLayers.Pixel>}
-     */
-    addControlToMap: function (control, px) {
-        // If a control doesn't have a div at this point, it belongs in the
-        // viewport.
-        control.outsideViewport = (control.div != null);
-        // If the map has a displayProjection, and the control doesn't, set
-        // the display projection.
-        if (this.displayProjection && !control.displayProjection) {
-            control.displayProjection = this.displayProjection;
-        }
-        control.setMap(this);
-        var div = control.draw(px);
-        if (div) {
-            if(!control.outsideViewport) {
-                div.style.zIndex = this.Z_INDEX_BASE['Control'] +
-                                    this.controls.length;
-                this.viewPortDiv.appendChild( div );
-            }
-        }
-        if(control.autoActivate) {
-            control.activate();
-        }
-    },
-    /**
-     * APIMethod: getControl
-     *
-     * Parameters:
-     * id - {String} ID of the control to return.
-     *
-     * Returns:
-     * {<OpenLayers.Control>} The control from the map's list of controls
-     *                        which has a matching 'id'. If none found,
-     *                        returns null.
-     */
-    getControl: function (id) {
-        var returnControl = null;
-        for(var i=0, len=this.controls.length; i<len; i++) {
-            var control = this.controls[i];
-            if (control.id == id) {
-                returnControl = control;
-                break;
-            }
-        }
-        return returnControl;
-    },
-    /**
-     * APIMethod: removeControl
-     * Remove a control from the map. Removes the control both from the map
-     *     object's internal array of controls, as well as from the map's
-     *     viewPort (assuming the control was not added outsideViewport)
-     *
-     * Parameters:
-     * control - {<OpenLayers.Control>} The control to remove.
-     */
-    removeControl: function (control) {
-        //make sure control is non-null and actually part of our map
-        if ( (control) && (control == this.getControl(control.id)) ) {
-            if (control.div && (control.div.parentNode == this.viewPortDiv)) {
-                this.viewPortDiv.removeChild(control.div);
-            }
-            OpenLayers.Util.removeItem(this.controls, control);
-        }
-    },
-  /********************************************************/
-  /*                                                      */
-  /*                  Popup Functions                     */
-  /*                                                      */
-  /*     The following functions deal with adding and     */
-  /*        removing Popups to and from the Map           */
-  /*                                                      */
-  /********************************************************/
-    /**
-     * APIMethod: addPopup
-     *
-     * Parameters:
-     * popup - {<OpenLayers.Popup>}
-     * exclusive - {Boolean} If true, closes all other popups first
-     */
-    addPopup: function(popup, exclusive) {
-        if (exclusive) {
-            //remove all other popups from screen
-            for (var i = this.popups.length - 1; i >= 0; --i) {
-                this.removePopup(this.popups[i]);
-            }
-        }
-        popup.map = this;
-        this.popups.push(popup);
-        var popupDiv = popup.draw();
-        if (popupDiv) {
-            popupDiv.style.zIndex = this.Z_INDEX_BASE['Popup'] +
-                                    this.popups.length;
-            this.layerContainerDiv.appendChild(popupDiv);
-        }
-    },
-    /**
-    * APIMethod: removePopup
-    *
-    * Parameters:
-    * popup - {<OpenLayers.Popup>}
-    */
-    removePopup: function(popup) {
-        OpenLayers.Util.removeItem(this.popups, popup);
-        if (popup.div) {
-            try { this.layerContainerDiv.removeChild(popup.div); }
-            catch (e) { } // Popups sometimes apparently get disconnected
-                      // from the layerContainerDiv, and cause complaints.
-        }
-        popup.map = null;
-    },
-  /********************************************************/
-  /*                                                      */
-  /*              Container Div Functions                 */
-  /*                                                      */
-  /*   The following functions deal with the access to    */
-  /*    and maintenance of the size of the container div  */
-  /*                                                      */
-  /********************************************************/
-    /**
-     * APIMethod: getSize
-     *
-     * Returns:
-     * {<OpenLayers.Size>} An <OpenLayers.Size> object that represents the
-     *                     size, in pixels, of the div into which OpenLayers
-     *                     has been loaded.
-     *                     Note - A clone() of this locally cached variable is
-     *                     returned, so as not to allow users to modify it.
-     */
-    getSize: function () {
-        var size = null;
-        if (this.size != null) {
-            size = this.size.clone();
-        }
-        return size;
-    },
-    /**
-     * APIMethod: updateSize
-     * This function should be called by any external code which dynamically
-     *     changes the size of the map div (because mozilla wont let us catch
-     *     the "onresize" for an element)
-     */
-    updateSize: function() {
-        // the div might have moved on the page, also
-        var newSize = this.getCurrentSize();
-        if (newSize && !isNaN(newSize.h) && !isNaN(newSize.w)) {
-            this.events.clearMouseCache();
-            var oldSize = this.getSize();
-            if (oldSize == null) {
-                this.size = oldSize = newSize;
-            }
-            if (!newSize.equals(oldSize)) {
-                // store the new size
-                this.size = newSize;
-                //notify layers of mapresize
-                for(var i=0, len=this.layers.length; i<len; i++) {
-                    this.layers[i].onMapResize();
-                }
-                var center = this.getCenter();
-                if (this.baseLayer != null && center != null) {
-                    var zoom = this.getZoom();
-                    this.zoom = null;
-                    this.setCenter(center, zoom);
-                }
-            }
-        }
-    },
-    /**
-     * Method: getCurrentSize
-     *
-     * Returns:
-     * {<OpenLayers.Size>} A new <OpenLayers.Size> object with the dimensions
-     *                     of the map div
-     */
-    getCurrentSize: function() {
-        var size = new OpenLayers.Size(this.div.clientWidth,
-                                       this.div.clientHeight);
-        if (size.w == 0 && size.h == 0 || isNaN(size.w) && isNaN(size.h)) {
-            size.w = this.div.offsetWidth;
-            size.h = this.div.offsetHeight;
-        }
-        if (size.w == 0 && size.h == 0 || isNaN(size.w) && isNaN(size.h)) {
-            size.w = parseInt(this.div.style.width);
-            size.h = parseInt(this.div.style.height);
-        }
-        return size;
-    },
-    /**
-     * Method: calculateBounds
-     *
-     * Parameters:
-     * center - {<OpenLayers.LonLat>} Default is this.getCenter()
-     * resolution - {float} Default is this.getResolution()
-     *
-     * Returns:
-     * {<OpenLayers.Bounds>} A bounds based on resolution, center, and
-     *                       current mapsize.
-     */
-    calculateBounds: function(center, resolution) {
-        var extent = null;
-        if (center == null) {
-            center = this.getCenter();
-        }
-        if (resolution == null) {
-            resolution = this.getResolution();
-        }
-        if ((center != null) && (resolution != null)) {
-            var size = this.getSize();
-            var w_deg = size.w * resolution;
-            var h_deg = size.h * resolution;
-            extent = new OpenLayers.Bounds(center.lon - w_deg / 2,
-                                           center.lat - h_deg / 2,
-                                           center.lon + w_deg / 2,
-                                           center.lat + h_deg / 2);
-        }
-        return extent;
-    },
-  /********************************************************/
-  /*                                                      */
-  /*            Zoom, Center, Pan Functions               */
-  /*                                                      */
-  /*    The following functions handle the validation,    */
-  /*   getting and setting of the Zoom Level and Center   */
-  /*       as well as the panning of the Map              */
-  /*                                                      */
-  /********************************************************/
-    /**
-     * APIMethod: getCenter
-     *
-     * Returns:
-     * {<OpenLayers.LonLat>}
-     */
-    getCenter: function () {
-        var center = null;
-        if (this.center) {
-            center = this.center.clone();
-        }
-        return center;
-    },
-    /**
-     * APIMethod: getZoom
-     *
-     * Returns:
-     * {Integer}
-     */
-    getZoom: function () {
-        return this.zoom;
-    },
-    /**
-     * APIMethod: pan
-     * Allows user to pan by a value of screen pixels
-     *
-     * Parameters:
-     * dx - {Integer}
-     * dy - {Integer}
-     * options - {Object} Options to configure panning:
-     *  - *animate* {Boolean} Use panTo instead of setCenter. Default is true.
-     *  - *dragging* {Boolean} Call setCenter with dragging true.  Default is
-     *    false.
-     */
-    pan: function(dx, dy, options) {
-        options = OpenLayers.Util.applyDefaults(options, {
-            animate: true,
-            dragging: false
-        });
-        // getCenter
-        var centerPx = this.getViewPortPxFromLonLat(this.getCenter());
-        // adjust
-        var newCenterPx = centerPx.add(dx, dy);
-        // only call setCenter if not dragging or there has been a change
-        if (!options.dragging || !newCenterPx.equals(centerPx)) {
-            var newCenterLonLat = this.getLonLatFromViewPortPx(newCenterPx);
-            if (options.animate) {
-                this.panTo(newCenterLonLat);
-            } else {
-                this.setCenter(newCenterLonLat, null, options.dragging);
-            }
-        }
-   },
-   /**
-     * APIMethod: panTo
-     * Allows user to pan to a new lonlat
-     * If the new lonlat is in the current extent the map will slide smoothly
-     *
-     * Parameters:
-     * lonlat - {<OpenLayers.Lonlat>}
-     */
-    panTo: function(lonlat) {
-        if (this.panMethod && this.getExtent().scale(this.panRatio).containsLonLat(lonlat)) {
-            if (!this.panTween) {
-                this.panTween = new OpenLayers.Tween(this.panMethod);
-            }
-            var center = this.getCenter();
-            // center will not change, don't do nothing
-            if (lonlat.lon == center.lon &&
-                lonlat.lat == center.lat) {
-                return;
-            }
-            var from = {
-                lon: center.lon,
-                lat: center.lat
-            };
-            var to = {
-                lon: lonlat.lon,
-                lat: lonlat.lat
-            };
-            this.panTween.start(from, to, this.panDuration, {
-                callbacks: {
-                    start: OpenLayers.Function.bind(function(lonlat) {
-                        this.events.triggerEvent("movestart");
-                    }, this),
-                    eachStep: OpenLayers.Function.bind(function(lonlat) {
-                        lonlat = new OpenLayers.LonLat(lonlat.lon, lonlat.lat);
-                        this.moveTo(lonlat, this.zoom, {
-                            'dragging': true,
-                            'noEvent': true
-                        });
-                    }, this),
-                    done: OpenLayers.Function.bind(function(lonlat) {
-                        lonlat = new OpenLayers.LonLat(lonlat.lon, lonlat.lat);
-                        this.moveTo(lonlat, this.zoom, {
-                            'noEvent': true
-                        });
-                        this.events.triggerEvent("moveend");
-                    }, this)
-                }
-            });
-        } else {
-            this.setCenter(lonlat);
-        }
-    },
-    /**
-     * APIMethod: setCenter
-     * Set the map center (and optionally, the zoom level).
-     *
-     * Parameters:
-     * lonlat - {<OpenLayers.LonLat>} The new center location.
-     * zoom - {Integer} Optional zoom level.
-     * dragging - {Boolean} Specifies whether or not to trigger
-     *                      movestart/end events
-     * forceZoomChange - {Boolean} Specifies whether or not to trigger zoom
-     *                             change events (needed on baseLayer change)
-     *
-     * TBD: reconsider forceZoomChange in 3.0
-     */
-    setCenter: function(lonlat, zoom, dragging, forceZoomChange) {
-        this.moveTo(lonlat, zoom, {
-            'dragging': dragging,
-            'forceZoomChange': forceZoomChange,
-            'caller': 'setCenter'
-        });
-    },
-    /**
-     * Method: moveTo
-     *
-     * Parameters:
-     * lonlat - {<OpenLayers.LonLat>}
-     * zoom - {Integer}
-     * options - {Object}
-     */
-    moveTo: function(lonlat, zoom, options) {
-        if (!options) {
-            options = {};
-        }
-        if (zoom != null) {
-            zoom = parseFloat(zoom);
-            if (!this.fractionalZoom) {
-                zoom = Math.round(zoom);
-            }
-        }
-        // dragging is false by default
-        var dragging = options.dragging;
-        // forceZoomChange is false by default
-        var forceZoomChange = options.forceZoomChange;
-        // noEvent is false by default
-        var noEvent = options.noEvent;
-        if (this.panTween && options.caller == "setCenter") {
-            this.panTween.stop();
-        }
-        if (!this.center && !this.isValidLonLat(lonlat)) {
-            lonlat = this.maxExtent.getCenterLonLat();
-        }
-        if(this.restrictedExtent != null) {
-            // In 3.0, decide if we want to change interpretation of maxExtent.
-            if(lonlat == null) {
-                lonlat = this.getCenter();
-            }
-            if(zoom == null) {
-                zoom = this.getZoom();
-            }
-            var resolution = this.getResolutionForZoom(zoom);
-            var extent = this.calculateBounds(lonlat, resolution);
-            if(!this.restrictedExtent.containsBounds(extent)) {
-                var maxCenter = this.restrictedExtent.getCenterLonLat();
-                if(extent.getWidth() > this.restrictedExtent.getWidth()) {
-                    lonlat = new OpenLayers.LonLat(maxCenter.lon, lonlat.lat);
-                } else if(extent.left < this.restrictedExtent.left) {
-                    lonlat = lonlat.add(this.restrictedExtent.left -
-                                        extent.left, 0);
-                } else if(extent.right > this.restrictedExtent.right) {
-                    lonlat = lonlat.add(this.restrictedExtent.right -
-                                        extent.right, 0);
-                }
-                if(extent.getHeight() > this.restrictedExtent.getHeight()) {
-                    lonlat = new OpenLayers.LonLat(lonlat.lon, maxCenter.lat);
-                } else if(extent.bottom < this.restrictedExtent.bottom) {
-                    lonlat = lonlat.add(0, this.restrictedExtent.bottom -
-                                        extent.bottom);
-                }
-                else if(extent.top > this.restrictedExtent.top) {
-                    lonlat = lonlat.add(0, this.restrictedExtent.top -
-                                        extent.top);
-                }
-            }
-        }
-        var zoomChanged = forceZoomChange || (
-                            (this.isValidZoomLevel(zoom)) &&
-                            (zoom != this.getZoom()) );
-        var centerChanged = (this.isValidLonLat(lonlat)) &&
-                            (!lonlat.equals(this.center));
-        // if neither center nor zoom will change, no need to do anything
-        if (zoomChanged || centerChanged || !dragging) {
-            if (!this.dragging && !noEvent) {
-                this.events.triggerEvent("movestart");
-            }
-            if (centerChanged) {
-                if ((!zoomChanged) && (this.center)) {
-                    // if zoom hasnt changed, just slide layerContainer
-                    //  (must be done before setting this.center to new value)
-                    this.centerLayerContainer(lonlat);
-                }
-                this.center = lonlat.clone();
-            }
-            // (re)set the layerContainerDiv's location
-            if ((zoomChanged) || (this.layerContainerOrigin == null)) {
-                this.layerContainerOrigin = this.center.clone();
-                this.layerContainerDiv.style.left = "0px";
-                this.layerContainerDiv.style.top  = "0px";
-            }
-            if (zoomChanged) {
-                this.zoom = zoom;
-                this.resolution = this.getResolutionForZoom(zoom);
-                // zoom level has changed, increment viewRequestID.
-                this.viewRequestID++;
-            }
-            var bounds = this.getExtent();
-            //send the move call to the baselayer and all the overlays
-            if(this.baseLayer.visibility) {
-                this.baseLayer.moveTo(bounds, zoomChanged, dragging);
-                if(dragging) {
-                    this.baseLayer.events.triggerEvent("move");
-                } else {
-                    this.baseLayer.events.triggerEvent("moveend",
-                        {"zoomChanged": zoomChanged}
-                    );
-                }
-            }
-            bounds = this.baseLayer.getExtent();
-            for (var i=0, len=this.layers.length; i<len; i++) {
-                var layer = this.layers[i];
-                if (layer !== this.baseLayer && !layer.isBaseLayer) {
-                    var inRange = layer.calculateInRange();
-                    if (layer.inRange != inRange) {
-                        // the inRange property has changed. If the layer is
-                        // no longer in range, we turn it off right away. If
-                        // the layer is no longer out of range, the moveTo
-                        // call below will turn on the layer.
-                        layer.inRange = inRange;
-                        if (!inRange) {
-                            layer.display(false);
-                        }
-                        this.events.triggerEvent("changelayer", {
-                            layer: layer, property: "visibility"
-                        });
-                    }
-                    if (inRange && layer.visibility) {
-                        layer.moveTo(bounds, zoomChanged, dragging);
-                        if(dragging) {
-                            layer.events.triggerEvent("move");
-                        } else {
-                            layer.events.triggerEvent("moveend",
-                                {"zoomChanged": zoomChanged}
-                            );
-                        }
-                    }
-                }
-            }
-            if (zoomChanged) {
-                //redraw popups
-                for (var i=0, len=this.popups.length; i<len; i++) {
-                    this.popups[i].updatePosition();
-                }
-            }
-            this.events.triggerEvent("move");
-            if (zoomChanged) { this.events.triggerEvent("zoomend"); }
-        }
-        // even if nothing was done, we want to notify of this
-        if (!dragging && !noEvent) {
-            this.events.triggerEvent("moveend");
-        }
-        // Store the map dragging state for later use
-        this.dragging = !!dragging;
-    },
-    /**
-     * Method: centerLayerContainer
-     * This function takes care to recenter the layerContainerDiv.
-     *
-     * Parameters:
-     * lonlat - {<OpenLayers.LonLat>}
-     */
-    centerLayerContainer: function (lonlat) {
-        var originPx = this.getViewPortPxFromLonLat(this.layerContainerOrigin);
-        var newPx = this.getViewPortPxFromLonLat(lonlat);
-        if ((originPx != null) && (newPx != null)) {
-            this.layerContainerDiv.style.left = Math.round(originPx.x - newPx.x) + "px";
-            this.layerContainerDiv.style.top  = Math.round(originPx.y - newPx.y) + "px";
-        }
-    },
-    /**
-     * Method: isValidZoomLevel
-     *
-     * Parameters:
-     * zoomLevel - {Integer}
-     *
-     * Returns:
-     * {Boolean} Whether or not the zoom level passed in is non-null and
-     *           within the min/max range of zoom levels.
-     */
-    isValidZoomLevel: function(zoomLevel) {
-       return ( (zoomLevel != null) &&
-                (zoomLevel >= 0) &&
-                (zoomLevel < this.getNumZoomLevels()) );
-    },
-    /**
-     * Method: isValidLonLat
-     *
-     * Parameters:
-     * lonlat - {<OpenLayers.LonLat>}
-     *
-     * Returns:
-     * {Boolean} Whether or not the lonlat passed in is non-null and within
-     *           the maxExtent bounds
-     */
-    isValidLonLat: function(lonlat) {
-        var valid = false;
-        if (lonlat != null) {
-            var maxExtent = this.getMaxExtent();
-            valid = maxExtent.containsLonLat(lonlat);
-        }
-        return valid;
-    },
-  /********************************************************/
-  /*                                                      */
-  /*                 Layer Options                        */
-  /*                                                      */
-  /*    Accessor functions to Layer Options parameters    */
-  /*                                                      */
-  /********************************************************/
-    /**
-     * APIMethod: getProjection
-     * This method returns a string representing the projection. In
-     *     the case of projection support, this will be the srsCode which
-     *     is loaded -- otherwise it will simply be the string value that
-     *     was passed to the projection at startup.
-     *
-     * FIXME: In 3.0, we will remove getProjectionObject, and instead
-     *     return a Projection object from this function.
-     *
-     * Returns:
-     * {String} The Projection string from the base layer or null.
-     */
-    getProjection: function() {
-        var projection = this.getProjectionObject();
-        return projection ? projection.getCode() : null;
-    },
-    /**
-     * APIMethod: getProjectionObject
-     * Returns the projection obect from the baselayer.
-     *
-     * Returns:
-     * {<OpenLayers.Projection>} The Projection of the base layer.
-     */
-    getProjectionObject: function() {
-        var projection = null;
-        if (this.baseLayer != null) {
-            projection = this.baseLayer.projection;
-        }
-        return projection;
-    },
-    /**
-     * APIMethod: getMaxResolution
-     *
-     * Returns:
-     * {String} The Map's Maximum Resolution
-     */
-    getMaxResolution: function() {
-        var maxResolution = null;
-        if (this.baseLayer != null) {
-            maxResolution = this.baseLayer.maxResolution;
-        }
-        return maxResolution;
-    },
-    /**
-     * APIMethod: getMaxExtent
-     *
-     * Parameters:
-     * options - {Object}
-     *
-     * Allowed Options:
-     * restricted - {Boolean} If true, returns restricted extent (if it is
-     *     available.)
-     *
-     * Returns:
-     * {<OpenLayers.Bounds>} The maxExtent property as set on the current
-     *     baselayer, unless the 'restricted' option is set, in which case
-     *     the 'restrictedExtent' option from the map is returned (if it
-     *     is set).
-     */
-    getMaxExtent: function (options) {
-        var maxExtent = null;
-        if(options && options.restricted && this.restrictedExtent){
-            maxExtent = this.restrictedExtent;
-        } else if (this.baseLayer != null) {
-            maxExtent = this.baseLayer.maxExtent;
-        }
-        return maxExtent;
-    },
-    /**
-     * APIMethod: getNumZoomLevels
-     *
-     * Returns:
-     * {Integer} The total number of zoom levels that can be displayed by the
-     *           current baseLayer.
-     */
-    getNumZoomLevels: function() {
-        var numZoomLevels = null;
-        if (this.baseLayer != null) {
-            numZoomLevels = this.baseLayer.numZoomLevels;
-        }
-        return numZoomLevels;
-    },
-  /********************************************************/
-  /*                                                      */
-  /*                 Baselayer Functions                  */
-  /*                                                      */
-  /*    The following functions, all publicly exposed     */
-  /*       in the API?, are all merely wrappers to the    */
-  /*       the same calls on whatever layer is set as     */
-  /*                the current base layer                */
-  /*                                                      */
-  /********************************************************/
-    /**
-     * APIMethod: getExtent
-     *
-     * Returns:
-     * {<OpenLayers.Bounds>} A Bounds object which represents the lon/lat
-     *                       bounds of the current viewPort.
-     *                       If no baselayer is set, returns null.
-     */
-    getExtent: function () {
-        var extent = null;
-        if (this.baseLayer != null) {
-            extent = this.baseLayer.getExtent();
-        }
-        return extent;
-    },
-    /**
-     * APIMethod: getResolution
-     *
-     * Returns:
-     * {Float} The current resolution of the map.
-     *         If no baselayer is set, returns null.
-     */
-    getResolution: function () {
-        var resolution = null;
-        if (this.baseLayer != null) {
-            resolution = this.baseLayer.getResolution();
-        } else if(this.allOverlays === true && this.layers.length > 0) {
-            // while adding the 1st layer to the map in allOverlays mode,
-            // this.baseLayer is not set yet when we need the resolution
-            // for calculateInRange.
-            resolution = this.layers[0].getResolution();
-        }
-        return resolution;
-    },
-    /**
-     * APIMethod: getUnits
-     *
-     * Returns:
-     * {Float} The current units of the map.
-     *         If no baselayer is set, returns null.
-     */
-    getUnits: function () {
-        var units = null;
-        if (this.baseLayer != null) {
-            units = this.baseLayer.units;
-        }
-        return units;
-    },
-     /**
-      * APIMethod: getScale
-      *
-      * Returns:
-      * {Float} The current scale denominator of the map.
-      *         If no baselayer is set, returns null.
-      */
-    getScale: function () {
-        var scale = null;
-        if (this.baseLayer != null) {
-            var res = this.getResolution();
-            var units = this.baseLayer.units;
-            scale = OpenLayers.Util.getScaleFromResolution(res, units);
-        }
-        return scale;
-    },
-    /**
-     * APIMethod: getZoomForExtent
-     *
-     * Parameters:
-     * bounds - {<OpenLayers.Bounds>}
-     * closest - {Boolean} Find the zoom level that most closely fits the
-     *     specified bounds. Note that this may result in a zoom that does
-     *     not exactly contain the entire extent.
-     *     Default is false.
-     *
-     * Returns:
-     * {Integer} A suitable zoom level for the specified bounds.
-     *           If no baselayer is set, returns null.
-     */
-    getZoomForExtent: function (bounds, closest) {
-        var zoom = null;
-        if (this.baseLayer != null) {
-            zoom = this.baseLayer.getZoomForExtent(bounds, closest);
-        }
-        return zoom;
-    },
-    /**
-     * APIMethod: getResolutionForZoom
-     *
-     * Parameter:
-     * zoom - {Float}
-     *
-     * Returns:
-     * {Float} A suitable resolution for the specified zoom.  If no baselayer
-     *     is set, returns null.
-     */
-    getResolutionForZoom: function(zoom) {
-        var resolution = null;
-        if(this.baseLayer) {
-            resolution = this.baseLayer.getResolutionForZoom(zoom);
-        }
-        return resolution;
-    },
-    /**
-     * APIMethod: getZoomForResolution
-     *
-     * Parameter:
-     * resolution - {Float}
-     * closest - {Boolean} Find the zoom level that corresponds to the absolute
-     *     closest resolution, which may result in a zoom whose corresponding
-     *     resolution is actually smaller than we would have desired (if this
-     *     is being called from a getZoomForExtent() call, then this means that
-     *     the returned zoom index might not actually contain the entire
-     *     extent specified... but it'll be close).
-     *     Default is false.
-     *
-     * Returns:
-     * {Integer} A suitable zoom level for the specified resolution.
-     *           If no baselayer is set, returns null.
-     */
-    getZoomForResolution: function(resolution, closest) {
-        var zoom = null;
-        if (this.baseLayer != null) {
-            zoom = this.baseLayer.getZoomForResolution(resolution, closest);
-        }
-        return zoom;
-    },
-  /********************************************************/
-  /*                                                      */
-  /*                  Zooming Functions                   */
-  /*                                                      */
-  /*    The following functions, all publicly exposed     */
-  /*       in the API, are all merely wrappers to the     */
-  /*               the setCenter() function               */
-  /*                                                      */
-  /********************************************************/
-    /**
-     * APIMethod: zoomTo
-     * Zoom to a specific zoom level
-     *
-     * Parameters:
-     * zoom - {Integer}
-     */
-    zoomTo: function(zoom) {
-        if (this.isValidZoomLevel(zoom)) {
-            this.setCenter(null, zoom);
-        }
-    },
-    /**
-     * APIMethod: zoomIn
-     *
-     * Parameters:
-     * zoom - {int}
-     */
-    zoomIn: function() {
-        this.zoomTo(this.getZoom() + 1);
-    },
-    /**
-     * APIMethod: zoomOut
-     *
-     * Parameters:
-     * zoom - {int}
-     */
-    zoomOut: function() {
-        this.zoomTo(this.getZoom() - 1);
-    },
-    /**
-     * APIMethod: zoomToExtent
-     * Zoom to the passed in bounds, recenter
-     *
-     * Parameters:
-     * bounds - {<OpenLayers.Bounds>}
-     * closest - {Boolean} Find the zoom level that most closely fits the
-     *     specified bounds. Note that this may result in a zoom that does
-     *     not exactly contain the entire extent.
-     *     Default is false.
-     *
-     */
-    zoomToExtent: function(bounds, closest) {
-        var center = bounds.getCenterLonLat();
-        if (this.baseLayer.wrapDateLine) {
-            var maxExtent = this.getMaxExtent();
-            //fix straddling bounds (in the case of a bbox that straddles the
-            // dateline, it's left and right boundaries will appear backwards.
-            // we fix this by allowing a right value that is greater than the
-            // max value at the dateline -- this allows us to pass a valid
-            // bounds to calculate zoom)
-            //
-            bounds = bounds.clone();
-            while (bounds.right < bounds.left) {
-                bounds.right += maxExtent.getWidth();
-            }
-            //if the bounds was straddling (see above), then the center point
-            // we got from it was wrong. So we take our new bounds and ask it
-            // for the center. Because our new bounds is at least partially
-            // outside the bounds of maxExtent, the new calculated center
-            // might also be. We don't want to pass a bad center value to
-            // setCenter, so we have it wrap itself across the date line.
-            //
-            center = bounds.getCenterLonLat().wrapDateLine(maxExtent);
-        }
-        this.setCenter(center, this.getZoomForExtent(bounds, closest));
-    },
-    /**
-     * APIMethod: zoomToMaxExtent
-     * Zoom to the full extent and recenter.
-     *
-     * Parameters:
-     * options -
-     *
-     * Allowed Options:
-     * restricted - {Boolean} True to zoom to restricted extent if it is
-     *     set. Defaults to true.
-     */
-    zoomToMaxExtent: function(options) {
-        //restricted is true by default
-        var restricted = (options) ? options.restricted : true;
-        var maxExtent = this.getMaxExtent({
-            'restricted': restricted
-        });
-        this.zoomToExtent(maxExtent);
-    },
-    /**
-     * APIMethod: zoomToScale
-     * Zoom to a specified scale
-     *
-     * Parameters:
-     * scale - {float}
-     * closest - {Boolean} Find the zoom level that most closely fits the
-     *     specified scale. Note that this may result in a zoom that does
-     *     not exactly contain the entire extent.
-     *     Default is false.
-     *
-     */
-    zoomToScale: function(scale, closest) {
-        var res = OpenLayers.Util.getResolutionFromScale(scale,
-                                                         this.baseLayer.units);
-        var size = this.getSize();
-        var w_deg = size.w * res;
-        var h_deg = size.h * res;
-        var center = this.getCenter();
-        var extent = new OpenLayers.Bounds(center.lon - w_deg / 2,
-                                           center.lat - h_deg / 2,
-                                           center.lon + w_deg / 2,
-                                           center.lat + h_deg / 2);
-        this.zoomToExtent(extent, closest);
-    },
-  /********************************************************/
-  /*                                                      */
-  /*             Translation Functions                    */
-  /*                                                      */
-  /*      The following functions translate between       */
-  /*           LonLat, LayerPx, and ViewPortPx            */
-  /*                                                      */
-  /********************************************************/
-  //
-  // TRANSLATION: LonLat <-> ViewPortPx
-  //
-    /**
-     * Method: getLonLatFromViewPortPx
-     *
-     * Parameters:
-     * viewPortPx - {<OpenLayers.Pixel>}
-     *
-     * Returns:
-     * {<OpenLayers.LonLat>} An OpenLayers.LonLat which is the passed-in view
-     *                       port <OpenLayers.Pixel>, translated into lon/lat
-     *                       by the current base layer.
-     */
-    getLonLatFromViewPortPx: function (viewPortPx) {
-        var lonlat = null;
-        if (this.baseLayer != null) {
-            lonlat = this.baseLayer.getLonLatFromViewPortPx(viewPortPx);
-        }
-        return lonlat;
-    },
-    /**
-     * APIMethod: getViewPortPxFromLonLat
-     *
-     * Parameters:
-     * lonlat - {<OpenLayers.LonLat>}
-     *
-     * Returns:
-     * {<OpenLayers.Pixel>} An OpenLayers.Pixel which is the passed-in
-     *                      <OpenLayers.LonLat>, translated into view port
-     *                      pixels by the current base layer.
-     */
-    getViewPortPxFromLonLat: function (lonlat) {
-        var px = null;
-        if (this.baseLayer != null) {
-            px = this.baseLayer.getViewPortPxFromLonLat(lonlat);
-        }
-        return px;
-    },
-  //
-  // CONVENIENCE TRANSLATION FUNCTIONS FOR API
-  //
-    /**
-     * APIMethod: getLonLatFromPixel
-     *
-     * Parameters:
-     * px - {<OpenLayers.Pixel>}
-     *
-     * Returns:
-     * {<OpenLayers.LonLat>} An OpenLayers.LonLat corresponding to the given
-     *                       OpenLayers.Pixel, translated into lon/lat by the
-     *                       current base layer
-     */
-    getLonLatFromPixel: function (px) {
-        return this.getLonLatFromViewPortPx(px);
-    },
-    /**
-     * APIMethod: getPixelFromLonLat
-     * Returns a pixel location given a map location.  The map location is
-     *     translated to an integer pixel location (in viewport pixel
-     *     coordinates) by the current base layer.
-     *
-     * Parameters:
-     * lonlat - {<OpenLayers.LonLat>} A map location.
-     *
-     * Returns:
-     * {<OpenLayers.Pixel>} An OpenLayers.Pixel corresponding to the
-     *     <OpenLayers.LonLat> translated into view port pixels by the current
-     *     base layer.
-     */
-    getPixelFromLonLat: function (lonlat) {
-        var px = this.getViewPortPxFromLonLat(lonlat);
-        px.x = Math.round(px.x);
-        px.y = Math.round(px.y);
-        return px;
-    },
-    /**
-     * Method: getGeodesicPixelSize
-     *
-     * Parameters:
-     * px - {<OpenLayers.Pixel>} The pixel to get the geodesic length for. If
-     *     not provided, the center pixel of the map viewport will be used.
-     *
-     * Returns:
-     * {<OpenLayers.Size>} The geodesic size of the pixel in kilometers.
-     */
-    getGeodesicPixelSize: function(px) {
-        var lonlat = px ? this.getLonLatFromPixel(px) : (this.getCenter() ||
-            new OpenLayers.LonLat(0, 0));
-        var res = this.getResolution();
-        var left = lonlat.add(-res / 2, 0);
-        var right = lonlat.add(res / 2, 0);
-        var bottom = lonlat.add(0, -res / 2);
-        var top = lonlat.add(0, res / 2);
-        var dest = new OpenLayers.Projection("EPSG:4326");
-        var source = this.getProjectionObject() || dest;
-        if(!source.equals(dest)) {
-            left.transform(source, dest);
-            right.transform(source, dest);
-            bottom.transform(source, dest);
-            top.transform(source, dest);
-        }
-        return new OpenLayers.Size(
-            OpenLayers.Util.distVincenty(left, right),
-            OpenLayers.Util.distVincenty(bottom, top)
-        );
-    },
-  //
-  // TRANSLATION: ViewPortPx <-> LayerPx
-  //
-    /**
-     * APIMethod: getViewPortPxFromLayerPx
-     *
-     * Parameters:
-     * layerPx - {<OpenLayers.Pixel>}
-     *
-     * Returns:
-     * {<OpenLayers.Pixel>} Layer Pixel translated into ViewPort Pixel
-     *                      coordinates
-     */
-    getViewPortPxFromLayerPx:function(layerPx) {
-        var viewPortPx = null;
-        if (layerPx != null) {
-            var dX = parseInt(this.layerContainerDiv.style.left);
-            var dY = parseInt(this.layerContainerDiv.style.top);
-            viewPortPx = layerPx.add(dX, dY);
-        }
-        return viewPortPx;
-    },
-    /**
-     * APIMethod: getLayerPxFromViewPortPx
-     *
-     * Parameters:
-     * viewPortPx - {<OpenLayers.Pixel>}
-     *
-     * Returns:
-     * {<OpenLayers.Pixel>} ViewPort Pixel translated into Layer Pixel
-     *                      coordinates
-     */
-    getLayerPxFromViewPortPx:function(viewPortPx) {
-        var layerPx = null;
-        if (viewPortPx != null) {
-            var dX = -parseInt(this.layerContainerDiv.style.left);
-            var dY = -parseInt(this.layerContainerDiv.style.top);
-            layerPx = viewPortPx.add(dX, dY);
-            if (isNaN(layerPx.x) || isNaN(layerPx.y)) {
-                layerPx = null;
-            }
-        }
-        return layerPx;
-    },
-  //
-  // TRANSLATION: LonLat <-> LayerPx
-  //
-    /**
-     * Method: getLonLatFromLayerPx
-     *
-     * Parameters:
-     * px - {<OpenLayers.Pixel>}
-     *
-     * Returns:
-     * {<OpenLayers.LonLat>}
-     */
-    getLonLatFromLayerPx: function (px) {
-       //adjust for displacement of layerContainerDiv
-       px = this.getViewPortPxFromLayerPx(px);
-       return this.getLonLatFromViewPortPx(px);
-    },
-    /**
-     * APIMethod: getLayerPxFromLonLat
-     *
-     * Parameters:
-     * lonlat - {<OpenLayers.LonLat>} lonlat
-     *
-     * Returns:
-     * {<OpenLayers.Pixel>} An OpenLayers.Pixel which is the passed-in
-     *                      <OpenLayers.LonLat>, translated into layer pixels
-     *                      by the current base layer
-     */
-    getLayerPxFromLonLat: function (lonlat) {
-       //adjust for displacement of layerContainerDiv
-       var px = this.getPixelFromLonLat(lonlat);
-       return this.getLayerPxFromViewPortPx(px);
-    },
-    CLASS_NAME: "OpenLayers.Map"
-});
-/**
- * Constant: TILE_WIDTH
- * {Integer} 256 Default tile width (unless otherwise specified)
- */
-OpenLayers.Map.TILE_WIDTH = 256;
-/**
- * Constant: TILE_HEIGHT
- * {Integer} 256 Default tile height (unless otherwise specified)
- */
-OpenLayers.Map.TILE_HEIGHT = 256;