--no commit message

Edmar Moretti
1 parent 73e4c672
Showing 5 changed files with 0 additions and 2863 deletions Show diff stats
ferramentas/ol3panel/Class.js
ferramentas/ol3panel/Control.js
ferramentas/ol3panel/Panel.js
ferramentas/ol3panel/Util.js
ferramentas/ol3panel/ol3Panel.php
@@ -1,163 +0,0 @@
-/* Copyright (c) 2006-2011 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/SingleFile.js
- */
-
-/**
- * Constructor: OpenLayers.Class
- * Base class used to construct all other classes. Includes support for 
- *     multiple inheritance. 
- *     
- * This constructor is new in OpenLayers 2.5.  At OpenLayers 3.0, the old 
- *     syntax for creating classes and dealing with inheritance 
- *     will be removed.
- * 
- * To create a new OpenLayers-style class, use the following syntax:
- * (code)
- *     var MyClass = OpenLayers.Class(prototype);
- * (end)
- *
- * To create a new OpenLayers-style class with multiple inheritance, use the
- *     following syntax:
- * (code)
- *     var MyClass = OpenLayers.Class(Class1, Class2, prototype);
- * (end)
- * 
- * Note that instanceof reflection will only reveal Class1 as superclass.
- *
- */
-OpenLayers.Class = function() {
-    var len = arguments.length;
-    var P = arguments[0];
-    var F = arguments[len-1];
-
-    var C = typeof F.initialize == "function" ?
-        F.initialize :
-        function(){ P.prototype.initialize.apply(this, arguments); };
-
-    if (len > 1) {
-        var newArgs = [C, P].concat(
-                Array.prototype.slice.call(arguments).slice(1, len-1), F);
-        OpenLayers.inherit.apply(null, newArgs);
-    } else {
-        C.prototype = F;
-    }
-    return C;
-};
-
-/**
- * Property: isPrototype
- * *Deprecated*.  This is no longer needed and will be removed at 3.0.
- */
-OpenLayers.Class.isPrototype = function () {};
-
-/**
- * APIFunction: OpenLayers.create
- * *Deprecated*.  Old method to create an OpenLayers style class.  Use the
- *     <OpenLayers.Class> constructor instead.
- *
- * Returns:
- * An OpenLayers class
- */
-OpenLayers.Class.create = function() {
-    return function() {
-        if (arguments && arguments[0] != OpenLayers.Class.isPrototype) {
-            this.initialize.apply(this, arguments);
-        }
-    };
-};
-
-/**
- * APIFunction: inherit
- * *Deprecated*.  Old method to inherit from one or more OpenLayers style
- *     classes.  Use the <OpenLayers.Class> constructor instead.
- *
- * Parameters:
- * class - One or more classes can be provided as arguments
- *
- * Returns:
- * An object prototype
- */
-OpenLayers.Class.inherit = function (P) {
-    var C = function() {
-       P.call(this);
-    };
-    var newArgs = [C].concat(Array.prototype.slice.call(arguments));
-    OpenLayers.inherit.apply(null, newArgs);
-    return C.prototype;
-};
-
-/**
- * Function: OpenLayers.inherit
- *
- * Parameters:
- * C - {Object} the class that inherits
- * P - {Object} the superclass to inherit from
- *
- * In addition to the mandatory C and P parameters, an arbitrary number of
- * objects can be passed, which will extend C.
- */
-OpenLayers.inherit = function(C, P) {
-   var F = function() {};
-   F.prototype = P.prototype;
-   C.prototype = new F;
-   var i, l, o;
-   for(i=2, l=arguments.length; i<l; i++) {
-       o = arguments[i];
-       if(typeof o === "function") {
-           o = o.prototype;
-       }
-       OpenLayers.Util.extend(C.prototype, o);
-   }
-};
-
-/**
- * APIFunction: extend
- * Copy all properties of a source object to a destination object.  Modifies
- *     the passed in destination object.  Any properties on the source object
- *     that are set to undefined will not be (re)set on the destination object.
- *
- * Parameters:
- * destination - {Object} The object that will be modified
- * source - {Object} The object with properties to be set on the destination
- *
- * Returns:
- * {Object} The destination object.
- */
-OpenLayers.Util = OpenLayers.Util || {};
-OpenLayers.Util.extend = function(destination, source) {
-    destination = destination || {};
-    if (source) {
-        for (var property in source) {
-            var value = source[property];
-            if (value !== undefined) {
-                destination[property] = value;
-            }
-        }
-
-        /**
-         * IE doesn't include the toString property when iterating over an object's
-         * properties with the for(property in object) syntax.  Explicitly check if
-         * the source has its own toString property.
-         */
-
-        /*
-         * FF/Windows < 2.0.0.13 reports "Illegal operation on WrappedNative
-         * prototype object" when calling hawOwnProperty if the source object
-         * is an instance of window.Event.
-         */
-
-        var sourceIsEvt = typeof window.Event == "function"
-                          && source instanceof window.Event;
-
-        if (!sourceIsEvt
-           && source.hasOwnProperty && source.hasOwnProperty("toString")) {
-            destination.toString = source.toString;
-        }
-    }
-    return destination;
-};
@@ -1,372 +0,0 @@
-/* Copyright (c) 2006-2011 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/BaseTypes/Class.js
- * @requires OpenLayers/Console.js
- */
-
-/**
- * Class: OpenLayers.Control
- * Controls affect the display or behavior of the map. They allow everything
- * from panning and zooming to displaying a scale indicator. Controls by 
- * default are added to the map they are contained within however it is
- * possible to add a control to an external div by passing the div in the
- * options parameter.
- * 
- * Example:
- * The following example shows how to add many of the common controls
- * to a map.
- * 
- * > var map = new OpenLayers.Map('map', { controls: [] });
- * >
- * > map.addControl(new OpenLayers.Control.PanZoomBar());
- * > map.addControl(new OpenLayers.Control.MouseToolbar());
- * > map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false}));
- * > map.addControl(new OpenLayers.Control.Permalink());
- * > map.addControl(new OpenLayers.Control.Permalink('permalink'));
- * > map.addControl(new OpenLayers.Control.MousePosition());
- * > map.addControl(new OpenLayers.Control.OverviewMap());
- * > map.addControl(new OpenLayers.Control.KeyboardDefaults());
- *
- * The next code fragment is a quick example of how to intercept 
- * shift-mouse click to display the extent of the bounding box
- * dragged out by the user.  Usually controls are not created
- * in exactly this manner.  See the source for a more complete 
- * example:
- *
- * > var control = new OpenLayers.Control();
- * > OpenLayers.Util.extend(control, {
- * >     draw: function () {
- * >         // this Handler.Box will intercept the shift-mousedown
- * >         // before Control.MouseDefault gets to see it
- * >         this.box = new OpenLayers.Handler.Box( control, 
- * >             {"done": this.notice},
- * >             {keyMask: OpenLayers.Handler.MOD_SHIFT});
- * >         this.box.activate();
- * >     },
- * >
- * >     notice: function (bounds) {
- * >         OpenLayers.Console.userError(bounds);
- * >     }
- * > }); 
- * > map.addControl(control);
- * 
- */
-OpenLayers.Control = OpenLayers.Class({
-
-    /** 
-     * Property: id 
-     * {String} 
-     */
-    id: null,
-    
-    /** 
-     * Property: map 
-     * {<OpenLayers.Map>} this gets set in the addControl() function in
-     * OpenLayers.Map 
-     */
-    map: null,
-
-    /** 
-     * APIProperty: div 
-     * {DOMElement} The element that contains the control, if not present the 
-     *     control is placed inside the map.
-     */
-    div: null,
-
-    /** 
-     * APIProperty: type 
-     * {Number} Controls can have a 'type'. The type determines the type of
-     * interactions which are possible with them when they are placed in an
-     * <OpenLayers.Control.Panel>. 
-     */
-    type: null, 
-
-    /** 
-     * Property: allowSelection
-     * {Boolean} By deafault, controls do not allow selection, because
-     * it may interfere with map dragging. If this is true, OpenLayers
-     * will not prevent selection of the control.
-     * Default is false.
-     */
-    allowSelection: false,  
-
-    /** 
-     * Property: displayClass 
-     * {string}  This property is used for CSS related to the drawing of the
-     * Control. 
-     */
-    displayClass: "",
-    
-    /**
-    * APIProperty: title  
-    * {string}  This property is used for showing a tooltip over the  
-    * Control.  
-    */ 
-    title: "",
-
-    /**
-     * APIProperty: autoActivate
-     * {Boolean} Activate the control when it is added to a map.  Default is
-     *     false.
-     */
-    autoActivate: false,
-
-    /** 
-     * APIProperty: active 
-     * {Boolean} The control is active (read-only).  Use <activate> and 
-     *     <deactivate> to change control state.
-     */
-    active: null,
-
-    /** 
-     * Property: handler 
-     * {<OpenLayers.Handler>} null
-     */
-    handler: 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: events
-     * {<OpenLayers.Events>} Events instance for listeners and triggering
-     *     control specific events.
-     */
-    events: null,
-
-    /**
-     * Constant: EVENT_TYPES
-     * {Array(String)} Supported application event types.  Register a listener
-     *     for a particular event with the following syntax:
-     * (code)
-     * control.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 control.events.object (a reference
-     *      to the control).
-     * element - {DOMElement} A reference to control.events.element (which
-     *      will be null unless documented otherwise).
-     *
-     * Supported map event types:
-     * activate - Triggered when activated.
-     * deactivate - Triggered when deactivated.
-     */
-    EVENT_TYPES: ["activate", "deactivate"],
-
-    /**
-     * Constructor: OpenLayers.Control
-     * Create an OpenLayers Control.  The options passed as a parameter
-     * directly extend the control.  For example passing the following:
-     * 
-     * > var control = new OpenLayers.Control({div: myDiv});
-     *
-     * Overrides the default div attribute value of null.
-     * 
-     * Parameters:
-     * options - {Object} 
-     */
-    initialize: function (options) {
-        // We do this before the extend so that instances can override
-        // className in options.
-        this.displayClass = 
-            this.CLASS_NAME.replace("OpenLayers.", "ol").replace(/\./g, "");
-        
-        OpenLayers.Util.extend(this, options);
-        
-        this.events = new OpenLayers.Events(this, null, this.EVENT_TYPES);
-        if(this.eventListeners instanceof Object) {
-            this.events.on(this.eventListeners);
-        }
-        if (this.id == null) {
-            this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
-        }
-    },
-
-    /**
-     * Method: destroy
-     * The destroy method is used to perform any clean up before the control
-     * is dereferenced.  Typically this is where event listeners are removed
-     * to prevent memory leaks.
-     */
-    destroy: function () {
-        if(this.events) {
-            if(this.eventListeners) {
-                this.events.un(this.eventListeners);
-            }
-            this.events.destroy();
-            this.events = null;
-        }
-        this.eventListeners = null;
-
-        // eliminate circular references
-        if (this.handler) {
-            this.handler.destroy();
-            this.handler = null;
-        }
-        if(this.handlers) {
-            for(var key in this.handlers) {
-                if(this.handlers.hasOwnProperty(key) &&
-                   typeof this.handlers[key].destroy == "function") {
-                    this.handlers[key].destroy();
-                }
-            }
-            this.handlers = null;
-        }
-        if (this.map) {
-            this.map.removeControl(this);
-            this.map = null;
-        }
-        this.div = null;
-    },
-
-    /** 
-     * Method: setMap
-     * Set the map property for the control. This is done through an accessor
-     * so that subclasses can override this and take special action once 
-     * they have their map variable set. 
-     *
-     * Parameters:
-     * map - {<OpenLayers.Map>} 
-     */
-    setMap: function(map) {
-        this.map = map;
-        if (this.handler) {
-            this.handler.setMap(map);
-        }
-    },
-  
-    /**
-     * Method: draw
-     * The draw method is called when the control is ready to be displayed
-     * on the page.  If a div has not been created one is created.  Controls
-     * with a visual component will almost always want to override this method 
-     * to customize the look of control. 
-     *
-     * Parameters:
-     * px - {<OpenLayers.Pixel>} The top-left pixel position of the control
-     *      or null.
-     *
-     * Returns:
-     * {DOMElement} A reference to the DIV DOMElement containing the control
-     */
-    draw: function (px) {
-        if (this.div == null) {
-            this.div = OpenLayers.Util.createDiv(this.id);
-            this.div.className = this.displayClass;
-            if (!this.allowSelection) {
-                this.div.className += " olControlNoSelect";
-                this.div.setAttribute("unselectable", "on", 0);
-                this.div.onselectstart = OpenLayers.Function.False; 
-            }    
-            if (this.title != "") {
-                this.div.title = this.title;
-            }
-        }
-        if (px != null) {
-            this.position = px.clone();
-        }
-        this.moveTo(this.position);
-        return this.div;
-    },
-
-    /**
-     * Method: moveTo
-     * Sets the left and top style attributes to the passed in pixel 
-     * coordinates.
-     *
-     * Parameters:
-     * px - {<OpenLayers.Pixel>}
-     */
-    moveTo: function (px) {
-        if ((px != null) && (this.div != null)) {
-            this.div.style.left = px.x + "px";
-            this.div.style.top = px.y + "px";
-        }
-    },
-
-    /**
-     * APIMethod: activate
-     * Explicitly activates a control and it's associated
-     * handler if one has been set.  Controls can be
-     * deactivated by calling the deactivate() method.
-     * 
-     * Returns:
-     * {Boolean}  True if the control was successfully activated or
-     *            false if the control was already active.
-     */
-    activate: function () {
-        if (this.active) {
-            return false;
-        }
-        if (this.handler) {
-            this.handler.activate();
-        }
-        this.active = true;
-        if(this.map) {
-            OpenLayers.Element.addClass(
-                this.map.viewPortDiv,
-                this.displayClass.replace(/ /g, "") + "Active"
-            );
-        }
-        this.events.triggerEvent("activate");
-        return true;
-    },
-    
-    /**
-     * APIMethod: deactivate
-     * Deactivates a control and it's associated handler if any.  The exact
-     * effect of this depends on the control itself.
-     * 
-     * Returns:
-     * {Boolean} True if the control was effectively deactivated or false
-     *           if the control was already inactive.
-     */
-    deactivate: function () {
-        if (this.active) {
-            if (this.handler) {
-                this.handler.deactivate();
-            }
-            this.active = false;
-            if(this.map) {
-                OpenLayers.Element.removeClass(
-                    this.map.viewPortDiv,
-                    this.displayClass.replace(/ /g, "") + "Active"
-                );
-            }
-            this.events.triggerEvent("deactivate");
-            return true;
-        }
-        return false;
-    },
-
-    CLASS_NAME: "OpenLayers.Control"
-});
-
-/**
- * Constant: OpenLayers.Control.TYPE_BUTTON
- */
-OpenLayers.Control.TYPE_BUTTON = 1;
-
-/**
- * Constant: OpenLayers.Control.TYPE_TOGGLE
- */
-OpenLayers.Control.TYPE_TOGGLE = 2;
-
-/**
- * Constant: OpenLayers.Control.TYPE_TOOL
- */
-OpenLayers.Control.TYPE_TOOL   = 3;
@@ -1,392 +0,0 @@
-/* Copyright (c) 2006-2011 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/Control.js
- */
-
-/**
- * Class: OpenLayers.Control.Panel
- * The Panel control is a container for other controls. With it toolbars
- * may be composed.
- *
- * Inherits from:
- *  - <OpenLayers.Control>
- */
-OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, {
-    /**
-     * Property: controls
-     * {Array(<OpenLayers.Control>)}
-     */
-    controls: null,    
-    
-    /**
-     * APIProperty: autoActivate
-     * {Boolean} Activate the control when it is added to a map.  Default is
-     *     true.
-     */
-    autoActivate: true,
-
-    /** 
-     * APIProperty: defaultControl
-     * {<OpenLayers.Control>} The control which is activated when the control is
-     * activated (turned on), which also happens at instantiation.
-     * If <saveState> is true, <defaultControl> will be nullified after the
-     * first activation of the panel.
-     */
-    defaultControl: null,
-    
-    /**
-     * APIProperty: saveState
-     * {Boolean} If set to true, the active state of this panel's controls will
-     * be stored on panel deactivation, and restored on reactivation. Default
-     * is false.
-     */
-    saveState: false,
-      
-    /**
-     * APIProperty: allowDepress
-     * {Boolean} If is true the <OpenLayers.Control.TYPE_TOOL> controls can 
-     *     be deactivated by clicking the icon that represents them.  Default 
-     *     is false.
-     */
-    allowDepress: false,
-    
-    /**
-     * Property: activeState
-     * {Object} stores the active state of this panel's controls.
-     */
-    activeState: null,
-
-    /**
-     * Constructor: OpenLayers.Control.Panel
-     * Create a new control panel.
-     *
-     * Each control in the panel is represented by an icon. When clicking 
-     *     on an icon, the <activateControl> method is called.
-     *
-     * Specific properties for controls on a panel:
-     * type - {Number} One of <OpenLayers.Control.TYPE_TOOL>,
-     *     <OpenLayers.Control.TYPE_TOGGLE>, <OpenLayers.Control.TYPE_BUTTON>.
-     *     If not provided, <OpenLayers.Control.TYPE_TOOL> is assumed.
-     * title - {string} Text displayed when mouse is over the icon that 
-     *     represents the control.     
-     *
-     * The <OpenLayers.Control.type> of a control determines the behavior when
-     * clicking its icon:
-     * <OpenLayers.Control.TYPE_TOOL> - The control is activated and other
-     *     controls of this type in the same panel are deactivated. This is
-     *     the default type.
-     * <OpenLayers.Control.TYPE_TOGGLE> - The active state of the control is
-     *     toggled.
-     * <OpenLayers.Control.TYPE_BUTTON> - The
-     *     <OpenLayers.Control.Button.trigger> method of the control is called,
-     *     but its active state is not changed.
-     *
-     * If a control is <OpenLayers.Control.active>, it will be drawn with the
-     * olControl[Name]ItemActive class, otherwise with the
-     * olControl[Name]ItemInactive class.
-     *
-     * Parameters:
-     * options - {Object} An optional object whose properties will be used
-     *     to extend the control.
-     */
-    initialize: function(options) {
-        OpenLayers.Control.prototype.initialize.apply(this, [options]);
-        this.controls = [];
-        this.activeState = {};
-    },
-
-    /**
-     * APIMethod: destroy
-     */
-    destroy: function() {
-        OpenLayers.Control.prototype.destroy.apply(this, arguments);
-        for (var ctl, i = this.controls.length - 1; i >= 0; i--) {
-            ctl = this.controls[i];
-            if (ctl.events) {
-                ctl.events.un({
-                    activate: this.iconOn,
-                    deactivate: this.iconOff
-                });
-            }
-            OpenLayers.Event.stopObservingElement(ctl.panel_div);
-            ctl.panel_div = null;
-        }
-        this.activeState = null;
-    },
-
-    /**
-     * APIMethod: activate
-     */
-    activate: function() {
-        if (OpenLayers.Control.prototype.activate.apply(this, arguments)) {
-            var control;
-            for (var i=0, len=this.controls.length; i<len; i++) {
-                control = this.controls[i];
-                if (control === this.defaultControl ||
-                            (this.saveState && this.activeState[control.id])) {
-                    control.activate();
-                }
-            }    
-            if (this.saveState === true) {
-                this.defaultControl = null;
-            }
-            this.redraw();
-            return true;
-        } else {
-            return false;
-        }
-    },
-    
-    /**
-     * APIMethod: deactivate
-     */
-    deactivate: function() {
-        if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) {
-            var control;
-            for (var i=0, len=this.controls.length; i<len; i++) {
-                control = this.controls[i];
-                this.activeState[control.id] = control.deactivate();
-            }    
-            this.redraw();
-            return true;
-        } else {
-            return false;
-        }
-    },
-    
-    /**
-     * Method: draw
-     *
-     * Returns:
-     * {DOMElement}
-     */    
-    draw: function() {
-        OpenLayers.Control.prototype.draw.apply(this, arguments);
-        this.addControlsToMap(this.controls);
-        return this.div;
-    },
-
-    /**
-     * Method: redraw
-     */
-    redraw: function() {
-        for (var l=this.div.childNodes.length, i=l-1; i>=0; i--) {
-            this.div.removeChild(this.div.childNodes[i]);
-        }
-        this.div.innerHTML = "";
-        if (this.active) {
-            for (var i=0, len=this.controls.length; i<len; i++) {
-                this.div.appendChild(this.controls[i].panel_div);
-            }
-        }
-    },
-
-    /**
-     * APIMethod: activateControl
-     * This method is called when the user click on the icon representing a 
-     *     control in the panel.
-     *
-     * Parameters:
-     * control - {<OpenLayers.Control>}
-     */
-    activateControl: function (control) {
-        if (!this.active) { return false; }
-        if (control.type == OpenLayers.Control.TYPE_BUTTON) {
-            control.trigger();
-            return;
-        }
-        if (control.type == OpenLayers.Control.TYPE_TOGGLE) {
-            if (control.active) {
-                control.deactivate();
-            } else {
-                control.activate();
-            }
-            return;
-        }
-        if (this.allowDepress && control.active) {
-            control.deactivate();
-        } else {
-            var c;
-            for (var i=0, len=this.controls.length; i<len; i++) {
-                c = this.controls[i];
-                if (c != control &&
-                   (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)) {
-                    c.deactivate();
-                }
-            }
-            control.activate();
-        }
-    },
-
-    /**
-     * APIMethod: addControls
-     * To build a toolbar, you add a set of controls to it. addControls
-     * lets you add a single control or a list of controls to the 
-     * Control Panel.
-     *
-     * Parameters:
-     * controls - {<OpenLayers.Control>} Controls to add in the panel.
-     */    
-    addControls: function(controls) {
-        if (!(OpenLayers.Util.isArray(controls))) {
-            controls = [controls];
-        }
-        this.controls = this.controls.concat(controls);
-        
-        // Give each control a panel_div which will be used later.
-        // Access to this div is via the panel_div attribute of the 
-        // control added to the panel.
-        // Also, stop mousedowns and clicks, but don't stop mouseup,
-        // since they need to pass through.
-        for (var i=0, len=controls.length; i<len; i++) {
-            var element = document.createElement("div");
-            element.className = controls[i].displayClass + "ItemInactive";
-            controls[i].panel_div = element;
-            if (controls[i].title != "") {
-                controls[i].panel_div.title = controls[i].title;
-            }
-            OpenLayers.Event.observe(controls[i].panel_div, "click", 
-                OpenLayers.Function.bind(this.onClick, this, controls[i]));
-            OpenLayers.Event.observe(controls[i].panel_div, "dblclick", 
-                OpenLayers.Function.bind(this.onDoubleClick, this, controls[i]));
-            OpenLayers.Event.observe(controls[i].panel_div, "mousedown", 
-                OpenLayers.Function.bindAsEventListener(OpenLayers.Event.stop));
-        }    
-
-        if (this.map) { // map.addControl() has already been called on the panel
-            this.addControlsToMap(controls);
-            this.redraw();
-        }
-    },
-   
-    /**
-     * Method: addControlsToMap
-     * Only for internal use in draw() and addControls() methods.
-     *
-     * Parameters:
-     * controls - {Array(<OpenLayers.Control>)} Controls to add into map.
-     */         
-    addControlsToMap: function (controls) {
-        var control;
-        for (var i=0, len=controls.length; i<len; i++) {
-            control = controls[i];
-            if (control.autoActivate === true) {
-                control.autoActivate = false;
-                this.map.addControl(control);
-                control.autoActivate = true;
-            } else {
-                this.map.addControl(control);
-                control.deactivate();
-            }
-            control.events.on({
-                activate: this.iconOn,
-                deactivate: this.iconOff
-            });
-        }  
-    },
-
-    /**
-     * Method: iconOn
-     * Internal use, for use only with "controls[i].events.on/un".
-     */
-     iconOn: function() {
-        var d = this.panel_div; // "this" refers to a control on panel!
-        d.className = d.className.replace(/ItemInactive$/, "ItemActive");
-    },
-
-    /**
-     * Method: iconOff
-     * Internal use, for use only with "controls[i].events.on/un".
-     */
-     iconOff: function() {
-        var d = this.panel_div; // "this" refers to a control on panel!
-        d.className = d.className.replace(/ItemActive$/, "ItemInactive");
-    },
-
-    /**
-     * Method: onClick
-     */
-    onClick: function (ctrl, evt) {
-        OpenLayers.Event.stop(evt ? evt : window.event);
-        this.activateControl(ctrl);
-    },
-
-    /**
-     * Method: onDoubleClick
-     */
-    onDoubleClick: function(ctrl, evt) {
-        OpenLayers.Event.stop(evt ? evt : window.event);
-    },
-
-    /**
-     * 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(control[property]) evaluates to true, the control will be
-     *     included in the array returned.  If no controls 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) {
-        var test = (typeof match.test == "function");
-        var found = OpenLayers.Array.filter(this.controls, function(item) {
-            return item[property] == match || (test && match.test(item[property]));
-        });
-        return found;
-    },
-
-    /**
-     * APIMethod: getControlsByName
-     * Get a list of contorls with names matching the given name.
-     *
-     * Parameter:
-     * match - {String | Object} A control 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(control.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 name.
-     *     An empty array is returned if no matches are found.
-     */
-    getControlsByName: function(match) {
-        return this.getControlsBy("name", match);
-    },
-
-    /**
-     * APIMethod: getControlsByClass
-     * Get a list of controls of a given type (CLASS_NAME).
-     *
-     * Parameter:
-     * match - {String | Object} A control class name.  The type 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 type.
-     *     An empty array is returned if no matches are found.
-     */
-    getControlsByClass: function(match) {
-        return this.getControlsBy("CLASS_NAME", match);
-    },
-
-    CLASS_NAME: "OpenLayers.Control.Panel"
-});
-
@@ -1,1839 +0,0 @@
-/* Copyright (c) 2006-2011 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/BaseTypes.js
- * @requires OpenLayers/BaseTypes/Bounds.js
- * @requires OpenLayers/BaseTypes/Element.js
- * @requires OpenLayers/BaseTypes/LonLat.js
- * @requires OpenLayers/BaseTypes/Pixel.js
- * @requires OpenLayers/BaseTypes/Size.js
- * @requires OpenLayers/Console.js
- * @requires OpenLayers/Lang.js
- */
-
-/**
- * Namespace: Util
- */
-OpenLayers.Util = OpenLayers.Util || {};
-
-/** 
- * Function: getElement
- * This is the old $() from prototype
- *
- * Parameters:
- * e - {String or DOMElement or Window}
- * Return:
- * {Array(DOMElement)}
- */
-OpenLayers.Util.getElement = function() {
-    var elements = [];
-
-    for (var i=0, len=arguments.length; i<len; i++) {
-        var element = arguments[i];
-        if (typeof element == 'string') {
-            element = document.getElementById(element);
-        }
-        if (arguments.length == 1) {
-            return element;
-        }
-        elements.push(element);
-    }
-    return elements;
-};
-
-/**
- * Function: isElement
- * A cross-browser implementation of "e instanceof Element".
- *
- * Parameters:
- * o - {Object} The object to test.
- *
- * Returns:
- * {Boolean}
- */
-OpenLayers.Util.isElement = function(o) {
-    return !!(o && o.nodeType === 1);
-};
-
-/**
- * Function: isArray
- * Tests that the provided object is an array.
- * This test handles the cross-IFRAME case not caught
- * by "a instanceof Array" and should be used instead.
- * 
- * Parameters:
- * a - {Object} the object test.
- * 
- * Returns
- * {Boolean} true if the object is an array.
- */
-OpenLayers.Util.isArray = function(a) {
-	return (Object.prototype.toString.call(a) === '[object Array]');
-};
-
-/** 
- * Maintain existing definition of $.
- */
-if(typeof window.$  === "undefined") {
-    window.$ = OpenLayers.Util.getElement;
-}
-
-/** 
- * Function: removeItem
- * Remove an object from an array. Iterates through the array
- *     to find the item, then removes it.
- *
- * Parameters:
- * array - {Array}
- * item - {Object}
- * 
- * Return
- * {Array} A reference to the array
- */
-OpenLayers.Util.removeItem = function(array, item) {
-    for(var i = array.length - 1; i >= 0; i--) {
-        if(array[i] == item) {
-            array.splice(i,1);
-            //break;more than once??
-        }
-    }
-    return array;
-};
-
-/**
- * Function: clearArray
- * *Deprecated*. This function will disappear in 3.0.
- * Please use "array.length = 0" instead.
- * 
- * Parameters:
- * array - {Array}
- */
-OpenLayers.Util.clearArray = function(array) {
-    OpenLayers.Console.warn(
-        OpenLayers.i18n(
-            "methodDeprecated", {'newMethod': 'array = []'}
-        )
-    );
-    array.length = 0;
-};
-
-/** 
- * Function: indexOf
- * Seems to exist already in FF, but not in MOZ.
- * 
- * Parameters:
- * array - {Array}
- * obj - {*}
- * 
- * Returns:
- * {Integer} The index at, which the first object was found in the array.
- *           If not found, returns -1.
- */
-OpenLayers.Util.indexOf = function(array, obj) {
-    // use the build-in function if available.
-    if (typeof array.indexOf == "function") {
-        return array.indexOf(obj);
-    } else {
-        for (var i = 0, len = array.length; i < len; i++) {
-            if (array[i] == obj) {
-                return i;
-            }
-        }
-        return -1;   
-    }
-};
-
-
-
-/**
- * Function: modifyDOMElement
- * 
- * Modifies many properties of a DOM element all at once.  Passing in 
- * null to an individual parameter will avoid setting the attribute.
- *
- * Parameters:
- * element - {DOMElement} DOM element to modify.
- * id - {String} The element id attribute to set.
- * px - {<OpenLayers.Pixel>} The left and top style position.
- * sz - {<OpenLayers.Size>}  The width and height style attributes.
- * position - {String}       The position attribute.  eg: absolute, 
- *                           relative, etc.
- * border - {String}         The style.border attribute.  eg:
- *                           solid black 2px
- * overflow - {String}       The style.overview attribute.  
- * opacity - {Float}         Fractional value (0.0 - 1.0)
- */
-OpenLayers.Util.modifyDOMElement = function(element, id, px, sz, position, 
-                                            border, overflow, opacity) {
-
-    if (id) {
-        element.id = id;
-    }
-    if (px) {
-        element.style.left = px.x + "px";
-        element.style.top = px.y + "px";
-    }
-    if (sz) {
-        element.style.width = sz.w + "px";
-        element.style.height = sz.h + "px";
-    }
-    if (position) {
-        element.style.position = position;
-    }
-    if (border) {
-        element.style.border = border;
-    }
-    if (overflow) {
-        element.style.overflow = overflow;
-    }
-    if (parseFloat(opacity) >= 0.0 && parseFloat(opacity) < 1.0) {
-        element.style.filter = 'alpha(opacity=' + (opacity * 100) + ')';
-        element.style.opacity = opacity;
-    } else if (parseFloat(opacity) == 1.0) {
-        element.style.filter = '';
-        element.style.opacity = '';
-    }
-};
-
-/** 
- * Function: createDiv
- * Creates a new div and optionally set some standard attributes.
- * Null may be passed to each parameter if you do not wish to
- * set a particular attribute.
- * Note - zIndex is NOT set on the resulting div.
- * 
- * Parameters:
- * id - {String} An identifier for this element.  If no id is
- *               passed an identifier will be created 
- *               automatically.
- * px - {<OpenLayers.Pixel>} The element left and top position. 
- * sz - {<OpenLayers.Size>} The element width and height.
- * imgURL - {String} A url pointing to an image to use as a 
- *                   background image.
- * position - {String} The style.position value. eg: absolute,
- *                     relative etc.
- * border - {String} The the style.border value. 
- *                   eg: 2px solid black
- * overflow - {String} The style.overflow value. Eg. hidden
- * opacity - {Float} Fractional value (0.0 - 1.0)
- * 
- * Returns: 
- * {DOMElement} A DOM Div created with the specified attributes.
- */
-OpenLayers.Util.createDiv = function(id, px, sz, imgURL, position, 
-                                     border, overflow, opacity) {
-
-    var dom = document.createElement('div');
-
-    if (imgURL) {
-        dom.style.backgroundImage = 'url(' + imgURL + ')';
-    }
-
-    //set generic properties
-    if (!id) {
-        id = OpenLayers.Util.createUniqueID("OpenLayersDiv");
-    }
-    if (!position) {
-        position = "absolute";
-    }
-    OpenLayers.Util.modifyDOMElement(dom, id, px, sz, position, 
-                                     border, overflow, opacity);
-
-    return dom;
-};
-
-/**
- * Function: createImage
- * Creates an img element with specific attribute values.
- *  
- * Parameters:
- * id - {String} The id field for the img.  If none assigned one will be
- *               automatically generated.
- * px - {<OpenLayers.Pixel>} The left and top positions.
- * sz - {<OpenLayers.Size>} The style.width and style.height values.
- * imgURL - {String} The url to use as the image source.
- * position - {String} The style.position value.
- * border - {String} The border to place around the image.
- * opacity - {Float} Fractional value (0.0 - 1.0)
- * delayDisplay - {Boolean} If true waits until the image has been
- *                          loaded.
- * 
- * Returns:
- * {DOMElement} A DOM Image created with the specified attributes.
- */
-OpenLayers.Util.createImage = function(id, px, sz, imgURL, position, border,
-                                       opacity, delayDisplay) {
-
-    var image = document.createElement("img");
-
-    //set generic properties
-    if (!id) {
-        id = OpenLayers.Util.createUniqueID("OpenLayersDiv");
-    }
-    if (!position) {
-        position = "relative";
-    }
-    OpenLayers.Util.modifyDOMElement(image, id, px, sz, position, 
-                                     border, null, opacity);
-
-    if(delayDisplay) {
-        image.style.display = "none";
-        OpenLayers.Event.observe(image, "load", 
-            OpenLayers.Function.bind(OpenLayers.Util.onImageLoad, image));
-        OpenLayers.Event.observe(image, "error", 
-            OpenLayers.Function.bind(OpenLayers.Util.onImageLoadError, image));
-        
-    }
-    
-    //set special properties
-    image.style.alt = id;
-    image.galleryImg = "no";
-    if (imgURL) {
-        image.src = imgURL;
-    }
-
-
-        
-    return image;
-};
-
-/**
- * Function: setOpacity
- * *Deprecated*.  This function has been deprecated. Instead, please use 
- *     <OpenLayers.Util.modifyDOMElement> 
- *     or 
- *     <OpenLayers.Util.modifyAlphaImageDiv>
- * 
- * Set the opacity of a DOM Element
- *     Note that for this function to work in IE, elements must "have layout"
- *     according to:
- *     http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/haslayout.asp
- *
- * Parameters:
- * element - {DOMElement} Set the opacity on this DOM element
- * opacity - {Float} Opacity value (0.0 - 1.0)
- */
-OpenLayers.Util.setOpacity = function(element, opacity) {
-    OpenLayers.Util.modifyDOMElement(element, null, null, null,
-                                     null, null, null, opacity);
-};
-
-/**
- * Function: onImageLoad
- * Bound to image load events.  For all images created with <createImage> or
- *     <createAlphaImageDiv>, this function will be bound to the load event.
- */
-OpenLayers.Util.onImageLoad = function() {
-    // The complex check here is to solve issues described in #480.
-    // Every time a map view changes, it increments the 'viewRequestID' 
-    // property. As the requests for the images for the new map view are sent
-    // out, they are tagged with this unique viewRequestID. 
-    // 
-    // If an image has no viewRequestID property set, we display it regardless, 
-    // but if it does have a viewRequestID property, we check that it matches 
-    // the viewRequestID set on the map.
-    // 
-    // If the viewRequestID on the map has changed, that means that the user
-    // has changed the map view since this specific request was sent out, and
-    // therefore this tile does not need to be displayed (so we do not execute
-    // this code that turns its display on).
-    //
-    if (!this.viewRequestID ||
-        (this.map && this.viewRequestID == this.map.viewRequestID)) { 
-        this.style.display = "";  
-    }
-    OpenLayers.Element.removeClass(this, "olImageLoadError");
-};
-
-/**
- * Property: IMAGE_RELOAD_ATTEMPTS
- * {Integer} How many times should we try to reload an image before giving up?
- *           Default is 0
- */
-OpenLayers.IMAGE_RELOAD_ATTEMPTS = 0;
-
-/**
- * Function: onImageLoadError 
- */
-OpenLayers.Util.onImageLoadError = function() {
-    this._attempts = (this._attempts) ? (this._attempts + 1) : 1;
-    if (this._attempts <= OpenLayers.IMAGE_RELOAD_ATTEMPTS) {
-        var urls = this.urls;
-        if (urls && OpenLayers.Util.isArray(urls) && urls.length > 1){
-            var src = this.src.toString();
-            var current_url, k;
-            for (k = 0; current_url = urls[k]; k++){
-                if(src.indexOf(current_url) != -1){
-                    break;
-                }
-            }
-            var guess = Math.floor(urls.length * Math.random());
-            var new_url = urls[guess];
-            k = 0;
-            while(new_url == current_url && k++ < 4){
-                guess = Math.floor(urls.length * Math.random());
-                new_url = urls[guess];
-            }
-            this.src = src.replace(current_url, new_url);
-        } else {
-            this.src = this.src;
-        }
-    } else {
-        OpenLayers.Element.addClass(this, "olImageLoadError");
-    }
-    this.style.display = "";
-};
-
-/**
- * Property: alphaHackNeeded
- * {Boolean} true if the png alpha hack is necessary and possible, false otherwise.
- */
-OpenLayers.Util.alphaHackNeeded = null;
-
-/**
- * Function: alphaHack
- * Checks whether it's necessary (and possible) to use the png alpha
- * hack which allows alpha transparency for png images under Internet
- * Explorer.
- * 
- * Returns:
- * {Boolean} true if the png alpha hack is necessary and possible, false otherwise.
- */
-OpenLayers.Util.alphaHack = function() {
-    if (OpenLayers.Util.alphaHackNeeded == null) {
-        var arVersion = navigator.appVersion.split("MSIE");
-        var version = parseFloat(arVersion[1]);
-        var filter = false;
-    
-        // IEs4Lin dies when trying to access document.body.filters, because 
-        // the property is there, but requires a DLL that can't be provided. This
-        // means that we need to wrap this in a try/catch so that this can
-        // continue.
-    
-        try { 
-            filter = !!(document.body.filters);
-        } catch (e) {}    
-    
-        OpenLayers.Util.alphaHackNeeded = (filter && 
-                                           (version >= 5.5) && (version < 7));
-    }
-    return OpenLayers.Util.alphaHackNeeded;
-};
-
-/** 
- * Function: modifyAlphaImageDiv
- * 
- * Parameters:
- * div - {DOMElement} Div containing Alpha-adjusted Image
- * id - {String}
- * px - {<OpenLayers.Pixel>}
- * sz - {<OpenLayers.Size>}
- * imgURL - {String}
- * position - {String}
- * border - {String}
- * sizing - {String} 'crop', 'scale', or 'image'. Default is "scale"
- * opacity - {Float} Fractional value (0.0 - 1.0)
- */ 
-OpenLayers.Util.modifyAlphaImageDiv = function(div, id, px, sz, imgURL, 
-                                               position, border, sizing, 
-                                               opacity) {
-
-    OpenLayers.Util.modifyDOMElement(div, id, px, sz, position,
-                                     null, null, opacity);
-
-    var img = div.childNodes[0];
-
-    if (imgURL) {
-        img.src = imgURL;
-    }
-    OpenLayers.Util.modifyDOMElement(img, div.id + "_innerImage", null, sz, 
-                                     "relative", border);
-    
-    if (OpenLayers.Util.alphaHack()) {
-        if(div.style.display != "none") {
-            div.style.display = "inline-block";
-        }
-        if (sizing == null) {
-            sizing = "scale";
-        }
-        
-        div.style.filter = "progid:DXImageTransform.Microsoft" +
-                           ".AlphaImageLoader(src='" + img.src + "', " +
-                           "sizingMethod='" + sizing + "')";
-        if (parseFloat(div.style.opacity) >= 0.0 && 
-            parseFloat(div.style.opacity) < 1.0) {
-            div.style.filter += " alpha(opacity=" + div.style.opacity * 100 + ")";
-        }
-
-        img.style.filter = "alpha(opacity=0)";
-    }
-};
-
-/** 
- * Function: createAlphaImageDiv
- * 
- * Parameters:
- * id - {String}
- * px - {<OpenLayers.Pixel>}
- * sz - {<OpenLayers.Size>}
- * imgURL - {String}
- * position - {String}
- * border - {String}
- * sizing - {String} 'crop', 'scale', or 'image'. Default is "scale"
- * opacity - {Float} Fractional value (0.0 - 1.0)
- * delayDisplay - {Boolean} If true waits until the image has been
- *                          loaded.
- * 
- * Returns:
- * {DOMElement} A DOM Div created with a DOM Image inside it. If the hack is 
- *              needed for transparency in IE, it is added.
- */ 
-OpenLayers.Util.createAlphaImageDiv = function(id, px, sz, imgURL, 
-                                               position, border, sizing, 
-                                               opacity, delayDisplay) {
-    
-    var div = OpenLayers.Util.createDiv();
-    var img = OpenLayers.Util.createImage(null, null, null, null, null, null, 
-                                          null, false);
-    div.appendChild(img);
-
-    if (delayDisplay) {
-        img.style.display = "none";
-        OpenLayers.Event.observe(img, "load",
-            OpenLayers.Function.bind(OpenLayers.Util.onImageLoad, div));
-        OpenLayers.Event.observe(img, "error",
-            OpenLayers.Function.bind(OpenLayers.Util.onImageLoadError, div));
-    }
-
-    OpenLayers.Util.modifyAlphaImageDiv(div, id, px, sz, imgURL, position, 
-                                        border, sizing, opacity);
-    
-    return div;
-};
-
-
-/** 
- * Function: upperCaseObject
- * Creates a new hashtable and copies over all the keys from the 
- *     passed-in object, but storing them under an uppercased
- *     version of the key at which they were stored.
- * 
- * Parameters: 
- * object - {Object}
- * 
- * Returns: 
- * {Object} A new Object with all the same keys but uppercased
- */
-OpenLayers.Util.upperCaseObject = function (object) {
-    var uObject = {};
-    for (var key in object) {
-        uObject[key.toUpperCase()] = object[key];
-    }
-    return uObject;
-};
-
-/** 
- * Function: applyDefaults
- * Takes an object and copies any properties that don't exist from
- *     another properties, by analogy with OpenLayers.Util.extend() from
- *     Prototype.js.
- * 
- * Parameters:
- * to - {Object} The destination object.
- * from - {Object} The source object.  Any properties of this object that
- *     are undefined in the to object will be set on the to object.
- *
- * Returns:
- * {Object} A reference to the to object.  Note that the to argument is modified
- *     in place and returned by this function.
- */
-OpenLayers.Util.applyDefaults = function (to, from) {
-    to = to || {};
-    /*
-     * FF/Windows < 2.0.0.13 reports "Illegal operation on WrappedNative
-     * prototype object" when calling hawOwnProperty if the source object is an
-     * instance of window.Event.
-     */
-    var fromIsEvt = typeof window.Event == "function"
-                    && from instanceof window.Event;
-
-    for (var key in from) {
-        if (to[key] === undefined ||
-            (!fromIsEvt && from.hasOwnProperty
-             && from.hasOwnProperty(key) && !to.hasOwnProperty(key))) {
-            to[key] = from[key];
-        }
-    }
-    /**
-     * IE doesn't include the toString property when iterating over an object's
-     * properties with the for(property in object) syntax.  Explicitly check if
-     * the source has its own toString property.
-     */
-    if(!fromIsEvt && from && from.hasOwnProperty
-       && from.hasOwnProperty('toString') && !to.hasOwnProperty('toString')) {
-        to.toString = from.toString;
-    }
-    
-    return to;
-};
-
-/**
- * Function: getParameterString
- * 
- * Parameters:
- * params - {Object}
- * 
- * Returns:
- * {String} A concatenation of the properties of an object in 
- *          http parameter notation. 
- *          (ex. <i>"key1=value1&key2=value2&key3=value3"</i>)
- *          If a parameter is actually a list, that parameter will then
- *          be set to a comma-seperated list of values (foo,bar) instead
- *          of being URL escaped (foo%3Abar). 
- */
-OpenLayers.Util.getParameterString = function(params) {
-    var paramsArray = [];
-    
-    for (var key in params) {
-      var value = params[key];
-      if ((value != null) && (typeof value != 'function')) {
-        var encodedValue;
-        if (typeof value == 'object' && value.constructor == Array) {
-          /* value is an array; encode items and separate with "," */
-          var encodedItemArray = [];
-          var item;
-          for (var itemIndex=0, len=value.length; itemIndex<len; itemIndex++) {
-            item = value[itemIndex];
-            encodedItemArray.push(encodeURIComponent(
-                (item === null || item === undefined) ? "" : item)
-            );
-          }
-          encodedValue = encodedItemArray.join(",");
-        }
-        else {
-          /* value is a string; simply encode */
-          encodedValue = encodeURIComponent(value);
-        }
-        paramsArray.push(encodeURIComponent(key) + "=" + encodedValue);
-      }
-    }
-    
-    return paramsArray.join("&");
-};
-
-/**
- * Function: urlAppend
- * Appends a parameter string to a url. This function includes the logic for
- * using the appropriate character (none, & or ?) to append to the url before
- * appending the param string.
- * 
- * Parameters:
- * url - {String} The url to append to
- * paramStr - {String} The param string to append
- * 
- * Returns:
- * {String} The new url
- */
-OpenLayers.Util.urlAppend = function(url, paramStr) {
-    var newUrl = url;
-    if(paramStr) {
-        var parts = (url + " ").split(/[?&]/);
-        newUrl += (parts.pop() === " " ?
-            paramStr :
-            parts.length ? "&" + paramStr : "?" + paramStr);
-    }
-    return newUrl;
-};
-
-/**
- * Property: ImgPath
- * {String} Default is ''.
- */
-OpenLayers.ImgPath = '';
-
-/** 
- * Function: getImagesLocation
- * 
- * Returns:
- * {String} The fully formatted image location string
- */
-OpenLayers.Util.getImagesLocation = function() {
-    return OpenLayers.ImgPath || (OpenLayers._getScriptLocation() + "img/");
-};
-
-
-/** 
- * Function: Try
- * Execute functions until one of them doesn't throw an error. 
- *     Capitalized because "try" is a reserved word in JavaScript.
- *     Taken directly from OpenLayers.Util.Try()
- * 
- * Parameters:
- * [*] - {Function} Any number of parameters may be passed to Try()
- *    It will attempt to execute each of them until one of them 
- *    successfully executes. 
- *    If none executes successfully, returns null.
- * 
- * Returns:
- * {*} The value returned by the first successfully executed function.
- */
-OpenLayers.Util.Try = function() {
-    var returnValue = null;
-
-    for (var i=0, len=arguments.length; i<len; i++) {
-      var lambda = arguments[i];
-      try {
-        returnValue = lambda();
-        break;
-      } catch (e) {}
-    }
-
-    return returnValue;
-};
-
-/**
- * Function: getXmlNodeValue
- * 
- * Parameters:
- * node - {XMLNode}
- * 
- * Returns:
- * {String} The text value of the given node, without breaking in firefox or IE
- */
-OpenLayers.Util.getXmlNodeValue = function(node) {
-    var val = null;
-    OpenLayers.Util.Try( 
-        function() {
-            val = node.text;
-            if (!val) {
-                val = node.textContent;
-            }
-            if (!val) {
-                val = node.firstChild.nodeValue;
-            }
-        }, 
-        function() {
-            val = node.textContent;
-        }); 
-    return val;
-};
-
-/** 
- * Function: mouseLeft
- * 
- * Parameters:
- * evt - {Event}
- * div - {HTMLDivElement}
- * 
- * Returns:
- * {Boolean}
- */
-OpenLayers.Util.mouseLeft = function (evt, div) {
-    // start with the element to which the mouse has moved
-    var target = (evt.relatedTarget) ? evt.relatedTarget : evt.toElement;
-    // walk up the DOM tree.
-    while (target != div && target != null) {
-        target = target.parentNode;
-    }
-    // if the target we stop at isn't the div, then we've left the div.
-    return (target != div);
-};
-
-/**
- * Property: precision
- * {Number} The number of significant digits to retain to avoid
- * floating point precision errors.
- *
- * We use 14 as a "safe" default because, although IEEE 754 double floats
- * (standard on most modern operating systems) support up to about 16
- * significant digits, 14 significant digits are sufficient to represent
- * sub-millimeter accuracy in any coordinate system that anyone is likely to
- * use with OpenLayers.
- *
- * If DEFAULT_PRECISION is set to 0, the original non-truncating behavior
- * of OpenLayers <2.8 is preserved. Be aware that this will cause problems
- * with certain projections, e.g. spherical Mercator.
- *
- */
-OpenLayers.Util.DEFAULT_PRECISION = 14;
-
-/**
- * Function: toFloat
- * Convenience method to cast an object to a Number, rounded to the
- * desired floating point precision.
- *
- * Parameters:
- * number    - {Number} The number to cast and round.
- * precision - {Number} An integer suitable for use with
- *      Number.toPrecision(). Defaults to OpenLayers.Util.DEFAULT_PRECISION.
- *      If set to 0, no rounding is performed.
- *
- * Returns:
- * {Number} The cast, rounded number.
- */
-OpenLayers.Util.toFloat = function (number, precision) {
-    if (precision == null) {
-        precision = OpenLayers.Util.DEFAULT_PRECISION;
-    }
-    if (typeof number !== "number") {
-        number = parseFloat(number);
-    }
-    return precision === 0 ? number :
-                             parseFloat(number.toPrecision(precision));
-};
-
-/**
- * Function: rad
- * 
- * Parameters:
- * x - {Float}
- * 
- * Returns:
- * {Float}
- */
-OpenLayers.Util.rad = function(x) {return x*Math.PI/180;};
-
-/**
- * Function: deg
- *
- * Parameters:
- * x - {Float}
- *
- * Returns:
- * {Float}
- */
-OpenLayers.Util.deg = function(x) {return x*180/Math.PI;};
-
-/**
- * Property: VincentyConstants
- * {Object} Constants for Vincenty functions.
- */
-OpenLayers.Util.VincentyConstants = {
-    a: 6378137,
-    b: 6356752.3142,
-    f: 1/298.257223563
-};
-
-/**
- * APIFunction: distVincenty
- * Given two objects representing points with geographic coordinates, this
- *     calculates the distance between those points on the surface of an
- *     ellipsoid.
- *
- * Parameters:
- * p1 - {<OpenLayers.LonLat>} (or any object with both .lat, .lon properties)
- * p2 - {<OpenLayers.LonLat>} (or any object with both .lat, .lon properties)
- *
- * Returns:
- * {Float} The distance (in km) between the two input points as measured on an
- *     ellipsoid.  Note that the input point objects must be in geographic
- *     coordinates (decimal degrees) and the return distance is in kilometers.
- */
-OpenLayers.Util.distVincenty = function(p1, p2) {
-    var ct = OpenLayers.Util.VincentyConstants;
-    var a = ct.a, b = ct.b, f = ct.f;
-
-    var L = OpenLayers.Util.rad(p2.lon - p1.lon);
-    var U1 = Math.atan((1-f) * Math.tan(OpenLayers.Util.rad(p1.lat)));
-    var U2 = Math.atan((1-f) * Math.tan(OpenLayers.Util.rad(p2.lat)));
-    var sinU1 = Math.sin(U1), cosU1 = Math.cos(U1);
-    var sinU2 = Math.sin(U2), cosU2 = Math.cos(U2);
-    var lambda = L, lambdaP = 2*Math.PI;
-    var iterLimit = 20;
-    while (Math.abs(lambda-lambdaP) > 1e-12 && --iterLimit>0) {
-        var sinLambda = Math.sin(lambda), cosLambda = Math.cos(lambda);
-        var sinSigma = Math.sqrt((cosU2*sinLambda) * (cosU2*sinLambda) +
-        (cosU1*sinU2-sinU1*cosU2*cosLambda) * (cosU1*sinU2-sinU1*cosU2*cosLambda));
-        if (sinSigma==0) {
-            return 0;  // co-incident points
-        }
-        var cosSigma = sinU1*sinU2 + cosU1*cosU2*cosLambda;
-        var sigma = Math.atan2(sinSigma, cosSigma);
-        var alpha = Math.asin(cosU1 * cosU2 * sinLambda / sinSigma);
-        var cosSqAlpha = Math.cos(alpha) * Math.cos(alpha);
-        var cos2SigmaM = cosSigma - 2*sinU1*sinU2/cosSqAlpha;
-        var C = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha));
-        lambdaP = lambda;
-        lambda = L + (1-C) * f * Math.sin(alpha) *
-        (sigma + C*sinSigma*(cos2SigmaM+C*cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)));
-    }
-    if (iterLimit==0) {
-        return NaN;  // formula failed to converge
-    }
-    var uSq = cosSqAlpha * (a*a - b*b) / (b*b);
-    var A = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)));
-    var B = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)));
-    var deltaSigma = B*sinSigma*(cos2SigmaM+B/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)-
-        B/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)));
-    var s = b*A*(sigma-deltaSigma);
-    var d = s.toFixed(3)/1000; // round to 1mm precision
-    return d;
-};
-
-/**
- * APIFunction: destinationVincenty
- * Calculate destination point given start point lat/long (numeric degrees),
- * bearing (numeric degrees) & distance (in m).
- * Adapted from Chris Veness work, see
- * http://www.movable-type.co.uk/scripts/latlong-vincenty-direct.html
- *
- * Parameters:
- * lonlat  - {<OpenLayers.LonLat>} (or any object with both .lat, .lon
- *     properties) The start point.
- * brng     - {Float} The bearing (degrees).
- * dist     - {Float} The ground distance (meters).
- *
- * Returns:
- * {<OpenLayers.LonLat>} The destination point.
- */
-OpenLayers.Util.destinationVincenty = function(lonlat, brng, dist) {
-    var u = OpenLayers.Util;
-    var ct = u.VincentyConstants;
-    var a = ct.a, b = ct.b, f = ct.f;
-
-    var lon1 = lonlat.lon;
-    var lat1 = lonlat.lat;
-
-    var s = dist;
-    var alpha1 = u.rad(brng);
-    var sinAlpha1 = Math.sin(alpha1);
-    var cosAlpha1 = Math.cos(alpha1);
-
-    var tanU1 = (1-f) * Math.tan(u.rad(lat1));
-    var cosU1 = 1 / Math.sqrt((1 + tanU1*tanU1)), sinU1 = tanU1*cosU1;
-    var sigma1 = Math.atan2(tanU1, cosAlpha1);
-    var sinAlpha = cosU1 * sinAlpha1;
-    var cosSqAlpha = 1 - sinAlpha*sinAlpha;
-    var uSq = cosSqAlpha * (a*a - b*b) / (b*b);
-    var A = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)));
-    var B = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)));
-
-    var sigma = s / (b*A), sigmaP = 2*Math.PI;
-    while (Math.abs(sigma-sigmaP) > 1e-12) {
-        var cos2SigmaM = Math.cos(2*sigma1 + sigma);
-        var sinSigma = Math.sin(sigma);
-        var cosSigma = Math.cos(sigma);
-        var deltaSigma = B*sinSigma*(cos2SigmaM+B/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)-
-            B/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)));
-        sigmaP = sigma;
-        sigma = s / (b*A) + deltaSigma;
-    }
-
-    var tmp = sinU1*sinSigma - cosU1*cosSigma*cosAlpha1;
-    var lat2 = Math.atan2(sinU1*cosSigma + cosU1*sinSigma*cosAlpha1,
-        (1-f)*Math.sqrt(sinAlpha*sinAlpha + tmp*tmp));
-    var lambda = Math.atan2(sinSigma*sinAlpha1, cosU1*cosSigma - sinU1*sinSigma*cosAlpha1);
-    var C = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha));
-    var L = lambda - (1-C) * f * sinAlpha *
-        (sigma + C*sinSigma*(cos2SigmaM+C*cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)));
-
-    var revAz = Math.atan2(sinAlpha, -tmp);  // final bearing
-
-    return new OpenLayers.LonLat(lon1+u.deg(L), u.deg(lat2));
-};
-
-/**
- * Function: getParameters
- * Parse the parameters from a URL or from the current page itself into a 
- *     JavaScript Object. Note that parameter values with commas are separated
- *     out into an Array.
- * 
- * Parameters:
- * url - {String} Optional url used to extract the query string.
- *                If url is null or is not supplied, query string is taken 
- *                from the page location.
- * 
- * Returns:
- * {Object} An object of key/value pairs from the query string.
- */
-OpenLayers.Util.getParameters = function(url) {
-    // if no url specified, take it from the location bar
-    url = (url === null || url === undefined) ? window.location.href : url;
-
-    //parse out parameters portion of url string
-    var paramsString = "";
-    if (OpenLayers.String.contains(url, '?')) {
-        var start = url.indexOf('?') + 1;
-        var end = OpenLayers.String.contains(url, "#") ?
-                    url.indexOf('#') : url.length;
-        paramsString = url.substring(start, end);
-    }
-
-    var parameters = {};
-    var pairs = paramsString.split(/[&;]/);
-    for(var i=0, len=pairs.length; i<len; ++i) {
-        var keyValue = pairs[i].split('=');
-        if (keyValue[0]) {
-
-            var key = keyValue[0];
-            try {
-                key = decodeURIComponent(key);
-            } catch (err) {
-                key = unescape(key);
-            }
-            
-            // being liberal by replacing "+" with " "
-            var value = (keyValue[1] || '').replace(/\+/g, " ");
-
-            try {
-                value = decodeURIComponent(value);
-            } catch (err) {
-                value = unescape(value);
-            }
-            
-            // follow OGC convention of comma delimited values
-            value = value.split(",");
-
-            //if there's only one value, do not return as array                    
-            if (value.length == 1) {
-                value = value[0];
-            }                
-            
-            parameters[key] = value;
-         }
-     }
-    return parameters;
-};
-
-/**
- * Function: getArgs
- * *Deprecated*.  Will be removed in 3.0.  Please use instead
- *     <OpenLayers.Util.getParameters>
- * 
- * Parameters:
- * url - {String} Optional url used to extract the query string.
- *                If null, query string is taken from page location.
- * 
- * Returns:
- * {Object} An object of key/value pairs from the query string.
- */
-OpenLayers.Util.getArgs = function(url) {
-    OpenLayers.Console.warn(
-        OpenLayers.i18n(
-            "methodDeprecated", {'newMethod': 'OpenLayers.Util.getParameters'}
-        )
-    );
-    return OpenLayers.Util.getParameters(url);
-};
-
-/**
- * Property: lastSeqID
- * {Integer} The ever-incrementing count variable.
- *           Used for generating unique ids.
- */
-OpenLayers.Util.lastSeqID = 0;
-
-/**
- * Function: createUniqueID
- * Create a unique identifier for this session.  Each time this function
- *     is called, a counter is incremented.  The return will be the optional
- *     prefix (defaults to "id_") appended with the counter value.
- * 
- * Parameters:
- * prefix {String} Optionsal string to prefix unique id. Default is "id_".
- * 
- * Returns:
- * {String} A unique id string, built on the passed in prefix.
- */
-OpenLayers.Util.createUniqueID = function(prefix) {
-    if (prefix == null) {
-        prefix = "id_";
-    }
-    OpenLayers.Util.lastSeqID += 1; 
-    return prefix + OpenLayers.Util.lastSeqID;        
-};
-
-/**
- * Constant: INCHES_PER_UNIT
- * {Object} Constant inches per unit -- borrowed from MapServer mapscale.c
- * derivation of nautical miles from http://en.wikipedia.org/wiki/Nautical_mile
- * Includes the full set of units supported by CS-MAP (http://trac.osgeo.org/csmap/)
- * and PROJ.4 (http://trac.osgeo.org/proj/)
- * The hardcoded table is maintain in a CS-MAP source code module named CSdataU.c
- * The hardcoded table of PROJ.4 units are in pj_units.c.
- */
-OpenLayers.INCHES_PER_UNIT = { 
-    'inches': 1.0,
-    'ft': 12.0,
-    'mi': 63360.0,
-    'm': 39.3701,
-    'km': 39370.1,
-    'dd': 4374754,
-    'yd': 36
-};
-OpenLayers.INCHES_PER_UNIT["in"]= OpenLayers.INCHES_PER_UNIT.inches;
-OpenLayers.INCHES_PER_UNIT["degrees"] = OpenLayers.INCHES_PER_UNIT.dd;
-OpenLayers.INCHES_PER_UNIT["nmi"] = 1852 * OpenLayers.INCHES_PER_UNIT.m;
-
-// Units from CS-Map
-OpenLayers.METERS_PER_INCH = 0.02540005080010160020;
-OpenLayers.Util.extend(OpenLayers.INCHES_PER_UNIT, {
-    "Inch": OpenLayers.INCHES_PER_UNIT.inches,
-    "Meter": 1.0 / OpenLayers.METERS_PER_INCH,   //EPSG:9001
-    "Foot": 0.30480060960121920243 / OpenLayers.METERS_PER_INCH,   //EPSG:9003
-    "IFoot": 0.30480000000000000000 / OpenLayers.METERS_PER_INCH,   //EPSG:9002
-    "ClarkeFoot": 0.3047972651151 / OpenLayers.METERS_PER_INCH,   //EPSG:9005
-    "SearsFoot": 0.30479947153867624624 / OpenLayers.METERS_PER_INCH,   //EPSG:9041
-    "GoldCoastFoot": 0.30479971018150881758 / OpenLayers.METERS_PER_INCH,   //EPSG:9094
-    "IInch": 0.02540000000000000000 / OpenLayers.METERS_PER_INCH,
-    "MicroInch": 0.00002540000000000000 / OpenLayers.METERS_PER_INCH,
-    "Mil": 0.00000002540000000000 / OpenLayers.METERS_PER_INCH,
-    "Centimeter": 0.01000000000000000000 / OpenLayers.METERS_PER_INCH,
-    "Kilometer": 1000.00000000000000000000 / OpenLayers.METERS_PER_INCH,   //EPSG:9036
-    "Yard": 0.91440182880365760731 / OpenLayers.METERS_PER_INCH,
-    "SearsYard": 0.914398414616029 / OpenLayers.METERS_PER_INCH,   //EPSG:9040
-    "IndianYard": 0.91439853074444079983 / OpenLayers.METERS_PER_INCH,   //EPSG:9084
-    "IndianYd37": 0.91439523 / OpenLayers.METERS_PER_INCH,   //EPSG:9085
-    "IndianYd62": 0.9143988 / OpenLayers.METERS_PER_INCH,   //EPSG:9086
-    "IndianYd75": 0.9143985 / OpenLayers.METERS_PER_INCH,   //EPSG:9087
-    "IndianFoot": 0.30479951 / OpenLayers.METERS_PER_INCH,   //EPSG:9080
-    "IndianFt37": 0.30479841 / OpenLayers.METERS_PER_INCH,   //EPSG:9081
-    "IndianFt62": 0.3047996 / OpenLayers.METERS_PER_INCH,   //EPSG:9082
-    "IndianFt75": 0.3047995 / OpenLayers.METERS_PER_INCH,   //EPSG:9083
-    "Mile": 1609.34721869443738887477 / OpenLayers.METERS_PER_INCH,
-    "IYard": 0.91440000000000000000 / OpenLayers.METERS_PER_INCH,   //EPSG:9096
-    "IMile": 1609.34400000000000000000 / OpenLayers.METERS_PER_INCH,   //EPSG:9093
-    "NautM": 1852.00000000000000000000 / OpenLayers.METERS_PER_INCH,   //EPSG:9030
-    "Lat-66": 110943.316488932731 / OpenLayers.METERS_PER_INCH,
-    "Lat-83": 110946.25736872234125 / OpenLayers.METERS_PER_INCH,
-    "Decimeter": 0.10000000000000000000 / OpenLayers.METERS_PER_INCH,
-    "Millimeter": 0.00100000000000000000 / OpenLayers.METERS_PER_INCH,
-    "Dekameter": 10.00000000000000000000 / OpenLayers.METERS_PER_INCH,
-    "Decameter": 10.00000000000000000000 / OpenLayers.METERS_PER_INCH,
-    "Hectometer": 100.00000000000000000000 / OpenLayers.METERS_PER_INCH,
-    "GermanMeter": 1.0000135965 / OpenLayers.METERS_PER_INCH,   //EPSG:9031
-    "CaGrid": 0.999738 / OpenLayers.METERS_PER_INCH,
-    "ClarkeChain": 20.1166194976 / OpenLayers.METERS_PER_INCH,   //EPSG:9038
-    "GunterChain": 20.11684023368047 / OpenLayers.METERS_PER_INCH,   //EPSG:9033
-    "BenoitChain": 20.116782494375872 / OpenLayers.METERS_PER_INCH,   //EPSG:9062
-    "SearsChain": 20.11676512155 / OpenLayers.METERS_PER_INCH,   //EPSG:9042
-    "ClarkeLink": 0.201166194976 / OpenLayers.METERS_PER_INCH,   //EPSG:9039
-    "GunterLink": 0.2011684023368047 / OpenLayers.METERS_PER_INCH,   //EPSG:9034
-    "BenoitLink": 0.20116782494375872 / OpenLayers.METERS_PER_INCH,   //EPSG:9063
-    "SearsLink": 0.2011676512155 / OpenLayers.METERS_PER_INCH,   //EPSG:9043
-    "Rod": 5.02921005842012 / OpenLayers.METERS_PER_INCH,
-    "IntnlChain": 20.1168 / OpenLayers.METERS_PER_INCH,   //EPSG:9097
-    "IntnlLink": 0.201168 / OpenLayers.METERS_PER_INCH,   //EPSG:9098
-    "Perch": 5.02921005842012 / OpenLayers.METERS_PER_INCH,
-    "Pole": 5.02921005842012 / OpenLayers.METERS_PER_INCH,
-    "Furlong": 201.1684023368046 / OpenLayers.METERS_PER_INCH,
-    "Rood": 3.778266898 / OpenLayers.METERS_PER_INCH,
-    "CapeFoot": 0.3047972615 / OpenLayers.METERS_PER_INCH,
-    "Brealey": 375.00000000000000000000 / OpenLayers.METERS_PER_INCH,
-    "ModAmFt": 0.304812252984505969011938 / OpenLayers.METERS_PER_INCH,
-    "Fathom": 1.8288 / OpenLayers.METERS_PER_INCH,
-    "NautM-UK": 1853.184 / OpenLayers.METERS_PER_INCH,
-    "50kilometers": 50000.0 / OpenLayers.METERS_PER_INCH,
-    "150kilometers": 150000.0 / OpenLayers.METERS_PER_INCH
-});
-
-//unit abbreviations supported by PROJ.4
-OpenLayers.Util.extend(OpenLayers.INCHES_PER_UNIT, {
-    "mm": OpenLayers.INCHES_PER_UNIT["Meter"] / 1000.0,
-    "cm": OpenLayers.INCHES_PER_UNIT["Meter"] / 100.0,
-    "dm": OpenLayers.INCHES_PER_UNIT["Meter"] * 100.0,
-    "km": OpenLayers.INCHES_PER_UNIT["Meter"] * 1000.0,
-    "kmi": OpenLayers.INCHES_PER_UNIT["nmi"],    //International Nautical Mile
-    "fath": OpenLayers.INCHES_PER_UNIT["Fathom"], //International Fathom
-    "ch": OpenLayers.INCHES_PER_UNIT["IntnlChain"],  //International Chain
-    "link": OpenLayers.INCHES_PER_UNIT["IntnlLink"], //International Link
-    "us-in": OpenLayers.INCHES_PER_UNIT["inches"], //U.S. Surveyor's Inch
-    "us-ft": OpenLayers.INCHES_PER_UNIT["Foot"],	//U.S. Surveyor's Foot
-    "us-yd": OpenLayers.INCHES_PER_UNIT["Yard"],	//U.S. Surveyor's Yard
-    "us-ch": OpenLayers.INCHES_PER_UNIT["GunterChain"], //U.S. Surveyor's Chain
-    "us-mi": OpenLayers.INCHES_PER_UNIT["Mile"],   //U.S. Surveyor's Statute Mile
-    "ind-yd": OpenLayers.INCHES_PER_UNIT["IndianYd37"],  //Indian Yard
-    "ind-ft": OpenLayers.INCHES_PER_UNIT["IndianFt37"],  //Indian Foot
-    "ind-ch": 20.11669506 / OpenLayers.METERS_PER_INCH  //Indian Chain
-});
-
-/** 
- * Constant: DOTS_PER_INCH
- * {Integer} 72 (A sensible default)
- */
-OpenLayers.DOTS_PER_INCH = 72;
-
-/**
- * Function: normalizeScale
- * 
- * Parameters:
- * scale - {float}
- * 
- * Returns:
- * {Float} A normalized scale value, in 1 / X format. 
- *         This means that if a value less than one ( already 1/x) is passed
- *         in, it just returns scale directly. Otherwise, it returns 
- *         1 / scale
- */
-OpenLayers.Util.normalizeScale = function (scale) {
-    var normScale = (scale > 1.0) ? (1.0 / scale) 
-                                  : scale;
-    return normScale;
-};
-
-/**
- * Function: getResolutionFromScale
- * 
- * Parameters:
- * scale - {Float}
- * units - {String} Index into OpenLayers.INCHES_PER_UNIT hashtable.
- *                  Default is degrees
- * 
- * Returns:
- * {Float} The corresponding resolution given passed-in scale and unit 
- *     parameters.  If the given scale is falsey, the returned resolution will
- *     be undefined.
- */
-OpenLayers.Util.getResolutionFromScale = function (scale, units) {
-    var resolution;
-    if (scale) {
-        if (units == null) {
-            units = "degrees";
-        }
-        var normScale = OpenLayers.Util.normalizeScale(scale);
-        resolution = 1 / (normScale * OpenLayers.INCHES_PER_UNIT[units]
-                                        * OpenLayers.DOTS_PER_INCH);        
-    }
-    return resolution;
-};
-
-/**
- * Function: getScaleFromResolution
- * 
- * Parameters:
- * resolution - {Float}
- * units - {String} Index into OpenLayers.INCHES_PER_UNIT hashtable.
- *                  Default is degrees
- * 
- * Returns:
- * {Float} The corresponding scale given passed-in resolution and unit 
- *         parameters.
- */
-OpenLayers.Util.getScaleFromResolution = function (resolution, units) {
-
-    if (units == null) {
-        units = "degrees";
-    }
-
-    var scale = resolution * OpenLayers.INCHES_PER_UNIT[units] *
-                    OpenLayers.DOTS_PER_INCH;
-    return scale;
-};
-
-/**
- * Function: safeStopPropagation
- * *Deprecated*. This function has been deprecated. Please use directly 
- *     <OpenLayers.Event.stop> passing 'true' as the 2nd 
- *     argument (preventDefault)
- * 
- * Safely stop the propagation of an event *without* preventing
- *   the default browser action from occurring.
- * 
- * Parameter:
- * evt - {Event}
- */
-OpenLayers.Util.safeStopPropagation = function(evt) {
-    OpenLayers.Event.stop(evt, true);
-};
-
-/**
- * Function: pagePosition
- * Calculates the position of an element on the page (see
- * http://code.google.com/p/doctype/wiki/ArticlePageOffset)
- *
- * OpenLayers.Util.pagePosition is based on Yahoo's getXY method, which is
- * Copyright (c) 2006, Yahoo! Inc.
- * All rights reserved.
- * 
- * Redistribution and use of this software in source and binary forms, with or
- * without modification, are permitted provided that the following conditions
- * are met:
- * 
- * * Redistributions of source code must retain the above copyright notice,
- *   this list of conditions and the following disclaimer.
- * 
- * * Redistributions in binary form must reproduce the above copyright notice,
- *   this list of conditions and the following disclaimer in the documentation
- *   and/or other materials provided with the distribution.
- * 
- * * Neither the name of Yahoo! Inc. nor the names of its contributors may be
- *   used to endorse or promote products derived from this software without
- *   specific prior written permission of Yahoo! Inc.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
- * POSSIBILITY OF SUCH DAMAGE.
- *
- * Parameters:
- * forElement - {DOMElement}
- * 
- * Returns:
- * {Array} two item array, Left value then Top value.
- */
-OpenLayers.Util.pagePosition =  function(forElement) {
-    // NOTE: If element is hidden (display none or disconnected or any the
-    // ancestors are hidden) we get (0,0) by default but we still do the
-    // accumulation of scroll position.
-
-    var pos = [0, 0];
-    var viewportElement = OpenLayers.Util.getViewportElement();
-    if (!forElement || forElement == window || forElement == viewportElement) {
-        // viewport is always at 0,0 as that defined the coordinate system for
-        // this function - this avoids special case checks in the code below
-        return pos;
-    }
-
-    // Gecko browsers normally use getBoxObjectFor to calculate the position.
-    // When invoked for an element with an implicit absolute position though it
-    // can be off by one. Therefore the recursive implementation is used in
-    // those (relatively rare) cases.
-    var BUGGY_GECKO_BOX_OBJECT =
-        OpenLayers.IS_GECKO && document.getBoxObjectFor &&
-        OpenLayers.Element.getStyle(forElement, 'position') == 'absolute' &&
-        (forElement.style.top == '' || forElement.style.left == '');
-
-    var parent = null;
-    var box;
-
-    if (forElement.getBoundingClientRect) { // IE
-        box = forElement.getBoundingClientRect();
-        var scrollTop = viewportElement.scrollTop;
-        var scrollLeft = viewportElement.scrollLeft;
-
-        pos[0] = box.left + scrollLeft;
-        pos[1] = box.top + scrollTop;
-
-    } else if (document.getBoxObjectFor && !BUGGY_GECKO_BOX_OBJECT) { // gecko
-        // Gecko ignores the scroll values for ancestors, up to 1.9.  See:
-        // https://bugzilla.mozilla.org/show_bug.cgi?id=328881 and
-        // https://bugzilla.mozilla.org/show_bug.cgi?id=330619
-
-        box = document.getBoxObjectFor(forElement);
-        var vpBox = document.getBoxObjectFor(viewportElement);
-        pos[0] = box.screenX - vpBox.screenX;
-        pos[1] = box.screenY - vpBox.screenY;
-
-    } else { // safari/opera
-        pos[0] = forElement.offsetLeft;
-        pos[1] = forElement.offsetTop;
-        parent = forElement.offsetParent;
-        if (parent != forElement) {
-            while (parent) {
-                pos[0] += parent.offsetLeft;
-                pos[1] += parent.offsetTop;
-                parent = parent.offsetParent;
-            }
-        }
-
-        var browser = OpenLayers.BROWSER_NAME;
-
-        // opera & (safari absolute) incorrectly account for body offsetTop
-        if (browser == "opera" || (browser == "safari" &&
-              OpenLayers.Element.getStyle(forElement, 'position') == 'absolute')) {
-            pos[1] -= document.body.offsetTop;
-        }
-
-        // accumulate the scroll positions for everything but the body element
-        parent = forElement.offsetParent;
-        while (parent && parent != document.body) {
-            pos[0] -= parent.scrollLeft;
-            // see https://bugs.opera.com/show_bug.cgi?id=249965
-            if (browser != "opera" || parent.tagName != 'TR') {
-                pos[1] -= parent.scrollTop;
-            }
-            parent = parent.offsetParent;
-        }
-    }
-    
-    return pos;
-};
-
-/**
- * Function: getViewportElement
- * Returns die viewport element of the document. The viewport element is
- * usually document.documentElement, except in IE,where it is either
- * document.body or document.documentElement, depending on the document's
- * compatibility mode (see
- * http://code.google.com/p/doctype/wiki/ArticleClientViewportElement)
- */
-OpenLayers.Util.getViewportElement = function() {
-    var viewportElement = arguments.callee.viewportElement;
-    if (viewportElement == undefined) {
-        viewportElement = (OpenLayers.BROWSER_NAME == "msie" &&
-            document.compatMode != 'CSS1Compat') ? document.body :
-            document.documentElement;
-        arguments.callee.viewportElement = viewportElement;
-    }
-    return viewportElement;
-};
-
-/** 
- * Function: isEquivalentUrl
- * Test two URLs for equivalence. 
- * 
- * Setting 'ignoreCase' allows for case-independent comparison.
- * 
- * Comparison is based on: 
- *  - Protocol
- *  - Host (evaluated without the port)
- *  - Port (set 'ignorePort80' to ignore "80" values)
- *  - Hash ( set 'ignoreHash' to disable)
- *  - Pathname (for relative <-> absolute comparison) 
- *  - Arguments (so they can be out of order)
- *  
- * Parameters:
- * url1 - {String}
- * url2 - {String}
- * options - {Object} Allows for customization of comparison:
- *                    'ignoreCase' - Default is True
- *                    'ignorePort80' - Default is True
- *                    'ignoreHash' - Default is True
- *
- * Returns:
- * {Boolean} Whether or not the two URLs are equivalent
- */
-OpenLayers.Util.isEquivalentUrl = function(url1, url2, options) {
-    options = options || {};
-
-    OpenLayers.Util.applyDefaults(options, {
-        ignoreCase: true,
-        ignorePort80: true,
-        ignoreHash: true
-    });
-
-    var urlObj1 = OpenLayers.Util.createUrlObject(url1, options);
-    var urlObj2 = OpenLayers.Util.createUrlObject(url2, options);
-
-    //compare all keys except for "args" (treated below)
-    for(var key in urlObj1) {
-        if(key !== "args") {
-            if(urlObj1[key] != urlObj2[key]) {
-                return false;
-            }
-        }
-    }
-
-    // compare search args - irrespective of order
-    for(var key in urlObj1.args) {
-        if(urlObj1.args[key] != urlObj2.args[key]) {
-            return false;
-        }
-        delete urlObj2.args[key];
-    }
-    // urlObj2 shouldn't have any args left
-    for(var key in urlObj2.args) {
-        return false;
-    }
-    
-    return true;
-};
-
-/**
- * Function: createUrlObject
- * 
- * Parameters:
- * url - {String}
- * options - {Object} A hash of options.  Can be one of:
- *            ignoreCase: lowercase url,
- *            ignorePort80: don't include explicit port if port is 80,
- *            ignoreHash: Don't include part of url after the hash (#).
- * 
- * Returns:
- * {Object} An object with separate url, a, port, host, and args parsed out 
- *          and ready for comparison
- */
-OpenLayers.Util.createUrlObject = function(url, options) {
-    options = options || {};
-
-    // deal with relative urls first
-    if(!(/^\w+:\/\//).test(url)) {
-        var loc = window.location;
-        var port = loc.port ? ":" + loc.port : "";
-        var fullUrl = loc.protocol + "//" + loc.host.split(":").shift() + port;
-        if(url.indexOf("/") === 0) {
-            // full pathname
-            url = fullUrl + url;
-        } else {
-            // relative to current path
-            var parts = loc.pathname.split("/");
-            parts.pop();
-            url = fullUrl + parts.join("/") + "/" + url;
-        }
-    }
-  
-    if (options.ignoreCase) {
-        url = url.toLowerCase(); 
-    }
-
-    var a = document.createElement('a');
-    a.href = url;
-    
-    var urlObject = {};
-    
-    //host (without port)
-    urlObject.host = a.host.split(":").shift();
-
-    //protocol
-    urlObject.protocol = a.protocol;  
-
-    //port (get uniform browser behavior with port 80 here)
-    if(options.ignorePort80) {
-        urlObject.port = (a.port == "80" || a.port == "0") ? "" : a.port;
-    } else {
-        urlObject.port = (a.port == "" || a.port == "0") ? "80" : a.port;
-    }
-
-    //hash
-    urlObject.hash = (options.ignoreHash || a.hash === "#") ? "" : a.hash;  
-    
-    //args
-    var queryString = a.search;
-    if (!queryString) {
-        var qMark = url.indexOf("?");
-        queryString = (qMark != -1) ? url.substr(qMark) : "";
-    }
-    urlObject.args = OpenLayers.Util.getParameters(queryString);
-
-    //pathname (uniform browser behavior with leading "/")
-    urlObject.pathname = (a.pathname.charAt(0) == "/") ? a.pathname : "/" + a.pathname;
-    
-    return urlObject; 
-};
- 
-/**
- * Function: removeTail
- * Takes a url and removes everything after the ? and #
- * 
- * Parameters:
- * url - {String} The url to process
- * 
- * Returns:
- * {String} The string with all queryString and Hash removed
- */
-OpenLayers.Util.removeTail = function(url) {
-    var head = null;
-    
-    var qMark = url.indexOf("?");
-    var hashMark = url.indexOf("#");
-
-    if (qMark == -1) {
-        head = (hashMark != -1) ? url.substr(0,hashMark) : url;
-    } else {
-        head = (hashMark != -1) ? url.substr(0,Math.min(qMark, hashMark)) 
-                                  : url.substr(0, qMark);
-    }
-    return head;
-};
-
-/**
- * Constant: IS_GECKO
- * {Boolean} True if the userAgent reports the browser to use the Gecko engine
- */
-OpenLayers.IS_GECKO = (function() {
-    var ua = navigator.userAgent.toLowerCase();
-    return ua.indexOf("webkit") == -1 && ua.indexOf("gecko") != -1;
-})();
-
-/**
- * Constant: BROWSER_NAME
- * {String}
- * A substring of the navigator.userAgent property.  Depending on the userAgent
- *     property, this will be the empty string or one of the following:
- *     * "opera" -- Opera
- *     * "msie"  -- Internet Explorer
- *     * "safari" -- Safari
- *     * "firefox" -- Firefox
- *     * "mozilla" -- Mozilla
- */
-OpenLayers.BROWSER_NAME = (function() {
-    var name = "";
-    var ua = navigator.userAgent.toLowerCase();
-    if (ua.indexOf("opera") != -1) {
-        name = "opera";
-    } else if (ua.indexOf("msie") != -1) {
-        name = "msie";
-    } else if (ua.indexOf("safari") != -1) {
-        name = "safari";
-    } else if (ua.indexOf("mozilla") != -1) {
-        if (ua.indexOf("firefox") != -1) {
-            name = "firefox";
-        } else {
-            name = "mozilla";
-        }
-    }
-    return name;
-})();
-
-/**
- * Function: getBrowserName
- * 
- * Returns:
- * {String} A string which specifies which is the current 
- *          browser in which we are running. 
- * 
- *          Currently-supported browser detection and codes:
- *           * 'opera' -- Opera
- *           * 'msie'  -- Internet Explorer
- *           * 'safari' -- Safari
- *           * 'firefox' -- Firefox
- *           * 'mozilla' -- Mozilla
- * 
- *          If we are unable to property identify the browser, we 
- *           return an empty string.
- */
-OpenLayers.Util.getBrowserName = function() {
-    return OpenLayers.BROWSER_NAME;
-};
-
-/**
- * Method: getRenderedDimensions
- * Renders the contentHTML offscreen to determine actual dimensions for
- *     popup sizing. As we need layout to determine dimensions the content
- *     is rendered -9999px to the left and absolute to ensure the 
- *     scrollbars do not flicker
- *     
- * Parameters:
- * contentHTML
- * size - {<OpenLayers.Size>} If either the 'w' or 'h' properties is 
- *     specified, we fix that dimension of the div to be measured. This is 
- *     useful in the case where we have a limit in one dimension and must 
- *     therefore meaure the flow in the other dimension.
- * options - {Object}
- *
- * Allowed Options:
- *     displayClass - {String} Optional parameter.  A CSS class name(s) string
- *         to provide the CSS context of the rendered content.
- *     containerElement - {DOMElement} Optional parameter. Insert the HTML to 
- *         this node instead of the body root when calculating dimensions. 
- * 
- * Returns:
- * {OpenLayers.Size}
- */
-OpenLayers.Util.getRenderedDimensions = function(contentHTML, size, options) {
-    
-    var w, h;
-    
-    // create temp container div with restricted size
-    var container = document.createElement("div");
-    container.style.visibility = "hidden";
-        
-    var containerElement = (options && options.containerElement) 
-    	? options.containerElement : document.body;
-
-    //fix a dimension, if specified.
-    if (size) {
-        if (size.w) {
-            w = size.w;
-            container.style.width = w + "px";
-        } else if (size.h) {
-            h = size.h;
-            container.style.height = h + "px";
-        }
-    }
-
-    //add css classes, if specified
-    if (options && options.displayClass) {
-        container.className = options.displayClass;
-    }
-    
-    // create temp content div and assign content
-    var content = document.createElement("div");
-    content.innerHTML = contentHTML;
-    
-    // we need overflow visible when calculating the size
-    content.style.overflow = "visible";
-    if (content.childNodes) {
-        for (var i=0, l=content.childNodes.length; i<l; i++) {
-            if (!content.childNodes[i].style) continue;
-            content.childNodes[i].style.overflow = "visible";
-        }
-    }
-    
-    // add content to restricted container 
-    container.appendChild(content);
-    
-    // append container to body for rendering
-    containerElement.appendChild(container);
-    
-    // Opera and IE7 can't handle a node with position:aboslute if it inherits
-    // position:absolute from a parent.
-    var parentHasPositionAbsolute = false;
-    var parent = container.parentNode;
-    while (parent && parent.tagName.toLowerCase()!="body") {
-        var parentPosition = OpenLayers.Element.getStyle(parent, "position");
-        if(parentPosition == "absolute") {
-            parentHasPositionAbsolute = true;
-            break;
-        } else if (parentPosition && parentPosition != "static") {
-            break;
-        }
-        parent = parent.parentNode;
-    }
-
-    if(!parentHasPositionAbsolute) {
-        container.style.position = "absolute";
-    }
-    
-    // calculate scroll width of content and add corners and shadow width
-    if (!w) {
-        w = parseInt(content.scrollWidth);
-    
-        // update container width to allow height to adjust
-        container.style.width = w + "px";
-    }        
-    // capture height and add shadow and corner image widths
-    if (!h) {
-        h = parseInt(content.scrollHeight);
-    }
-
-    // remove elements
-    container.removeChild(content);
-    containerElement.removeChild(container);
-    
-    return new OpenLayers.Size(w, h);
-};
-
-/**
- * APIFunction: getScrollbarWidth
- * This function has been modified by the OpenLayers from the original version,
- *     written by Matthew Eernisse and released under the Apache 2 
- *     license here:
- * 
- *     http://www.fleegix.org/articles/2006/05/30/getting-the-scrollbar-width-in-pixels
- * 
- *     It has been modified simply to cache its value, since it is physically 
- *     impossible that this code could ever run in more than one browser at 
- *     once. 
- * 
- * Returns:
- * {Integer}
- */
-OpenLayers.Util.getScrollbarWidth = function() {
-    
-    var scrollbarWidth = OpenLayers.Util._scrollbarWidth;
-    
-    if (scrollbarWidth == null) {
-        var scr = null;
-        var inn = null;
-        var wNoScroll = 0;
-        var wScroll = 0;
-    
-        // Outer scrolling div
-        scr = document.createElement('div');
-        scr.style.position = 'absolute';
-        scr.style.top = '-1000px';
-        scr.style.left = '-1000px';
-        scr.style.width = '100px';
-        scr.style.height = '50px';
-        // Start with no scrollbar
-        scr.style.overflow = 'hidden';
-    
-        // Inner content div
-        inn = document.createElement('div');
-        inn.style.width = '100%';
-        inn.style.height = '200px';
-    
-        // Put the inner div in the scrolling div
-        scr.appendChild(inn);
-        // Append the scrolling div to the doc
-        document.body.appendChild(scr);
-    
-        // Width of the inner div sans scrollbar
-        wNoScroll = inn.offsetWidth;
-    
-        // Add the scrollbar
-        scr.style.overflow = 'scroll';
-        // Width of the inner div width scrollbar
-        wScroll = inn.offsetWidth;
-    
-        // Remove the scrolling div from the doc
-        document.body.removeChild(document.body.lastChild);
-    
-        // Pixel width of the scroller
-        OpenLayers.Util._scrollbarWidth = (wNoScroll - wScroll);
-        scrollbarWidth = OpenLayers.Util._scrollbarWidth;
-    }
-
-    return scrollbarWidth;
-};
-
-/**
- * APIFunction: getFormattedLonLat
- * This function will return latitude or longitude value formatted as 
- *
- * Parameters:
- * coordinate - {Float} the coordinate value to be formatted
- * axis - {String} value of either 'lat' or 'lon' to indicate which axis is to
- *          to be formatted (default = lat)
- * dmsOption - {String} specify the precision of the output can be one of:
- *           'dms' show degrees minutes and seconds
- *           'dm' show only degrees and minutes
- *           'd' show only degrees
- * 
- * Returns:
- * {String} the coordinate value formatted as a string
- */
-OpenLayers.Util.getFormattedLonLat = function(coordinate, axis, dmsOption) {
-    if (!dmsOption) {
-        dmsOption = 'dms';    //default to show degree, minutes, seconds
-    }
-	
-	coordinate = (coordinate+540)%360 - 180; // normalize for sphere being round
-	
-    var abscoordinate = Math.abs(coordinate);
-    var coordinatedegrees = Math.floor(abscoordinate);
-
-    var coordinateminutes = (abscoordinate - coordinatedegrees)/(1/60);
-    var tempcoordinateminutes = coordinateminutes;
-    coordinateminutes = Math.floor(coordinateminutes);
-    var coordinateseconds = (tempcoordinateminutes - coordinateminutes)/(1/60);
-    coordinateseconds =  Math.round(coordinateseconds*10);
-    coordinateseconds /= 10;
-
-    if( coordinateseconds >= 60) { 
-        coordinateseconds -= 60; 
-        coordinateminutes += 1; 
-        if( coordinateminutes >= 60) { 
-            coordinateminutes -= 60; 
-            coordinatedegrees += 1; 
-        } 
-    }
-    
-    if( coordinatedegrees < 10 ) {
-        coordinatedegrees = "0" + coordinatedegrees;
-    }
-    var str = coordinatedegrees + "\u00B0";
-
-    if (dmsOption.indexOf('dm') >= 0) {
-        if( coordinateminutes < 10 ) {
-            coordinateminutes = "0" + coordinateminutes;
-        }
-        str += coordinateminutes + "'";
-  
-        if (dmsOption.indexOf('dms') >= 0) {
-            if( coordinateseconds < 10 ) {
-                coordinateseconds = "0" + coordinateseconds;
-            }
-            str += coordinateseconds + '"';
-        }
-    }
-    
-    if (axis == "lon") {
-        str += coordinate < 0 ? OpenLayers.i18n("W") : OpenLayers.i18n("E");
-    } else {
-        str += coordinate < 0 ? OpenLayers.i18n("S") : OpenLayers.i18n("N");
-    }
-    return str;
-};
-
@@ -1,97 +0,0 @@
-var OpenLayers={
-	VERSION_NUMBER:"Release 2.11",
-	singleFile:true,
-	_getScriptLocation:(
-		function(){
-			var r=new RegExp("(^|(.*?\\/))(OpenLayers\.js)(\\?|$)"),
-			s=document.getElementsByTagName('script'),
-			src,
-			m,
-			l="";
-			for(var i=0,len=s.length;i<len;i++){
-				src=s[i].getAttribute('src');
-				if(src){
-					var m=src.match(r);
-					if(m){
-						l=m[1];
-						break;
-					}
-				}
-			}
-			return(
-				function(){
-					return l;
-				}
-			);
-		}
-	)()
-};
-OpenLayers.Util = OpenLayers.Util || {};
-OpenLayers.Util.lastSeqID = 0;
-OpenLayers.Util.isArray = function(a) {
-	return (Object.prototype.toString.call(a) === '[object Array]');
-};
-OpenLayers.Util.createUniqueID = function(prefix) {
-    if (prefix == null) {
-        prefix = "id_";
-    }
-    OpenLayers.Util.lastSeqID += 1; 
-    return prefix + OpenLayers.Util.lastSeqID;        
-};
-OpenLayers.Util.createDiv = function(id, px, sz, imgURL, position, 
-                                     border, overflow, opacity) {
-
-    var dom = document.createElement('div');
-
-    if (imgURL) {
-        dom.style.backgroundImage = 'url(' + imgURL + ')';
-    }
-
-    //set generic properties
-    if (!id) {
-        id = OpenLayers.Util.createUniqueID("OpenLayersDiv");
-    }
-    if (!position) {
-        position = "absolute";
-    }
-    OpenLayers.Util.modifyDOMElement(dom, id, px, sz, position, 
-                                     border, overflow, opacity);
-
-    return dom;
-};
-OpenLayers.Util.modifyDOMElement = function(element, id, px, sz, position, 
-                                            border, overflow, opacity) {
-
-    if (id) {
-        element.id = id;
-    }
-    if (px) {
-        element.style.left = px.x + "px";
-        element.style.top = px.y + "px";
-    }
-    if (sz) {
-        element.style.width = sz.w + "px";
-        element.style.height = sz.h + "px";
-    }
-    if (position) {
-        element.style.position = position;
-    }
-    if (border) {
-        element.style.border = border;
-    }
-    if (overflow) {
-        element.style.overflow = overflow;
-    }
-    if (parseFloat(opacity) >= 0.0 && parseFloat(opacity) < 1.0) {
-        element.style.filter = 'alpha(opacity=' + (opacity * 100) + ')';
-        element.style.opacity = opacity;
-    } else if (parseFloat(opacity) == 1.0) {
-        element.style.filter = '';
-        element.style.opacity = '';
-    }
-};
-<?php
-include("Class.js");
-include("Panel.js");
-include("Control.js");
-?>
	@@ -1,163 +0,0 @@	@@ -1,163 +0,0 @@
1	-/* Copyright (c) 2006-2011 by OpenLayers Contributors (see authors.txt for
2	- * full list of contributors). Published under the Clear BSD license.
3	- * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
4	- * full text of the license. */
5	-
6	-/**
7	- * @requires OpenLayers/SingleFile.js
8	- */
9	-
10	-/**
11	- * Constructor: OpenLayers.Class
12	- * Base class used to construct all other classes. Includes support for
13	- * multiple inheritance.
14	- *
15	- * This constructor is new in OpenLayers 2.5. At OpenLayers 3.0, the old
16	- * syntax for creating classes and dealing with inheritance
17	- * will be removed.
18	- *
19	- * To create a new OpenLayers-style class, use the following syntax:
20	- * (code)
21	- * var MyClass = OpenLayers.Class(prototype);
22	- * (end)
23	- *
24	- * To create a new OpenLayers-style class with multiple inheritance, use the
25	- * following syntax:
26	- * (code)
27	- * var MyClass = OpenLayers.Class(Class1, Class2, prototype);
28	- * (end)
29	- *
30	- * Note that instanceof reflection will only reveal Class1 as superclass.
31	- *
32	- */
33	-OpenLayers.Class = function() {
34	- var len = arguments.length;
35	- var P = arguments[0];
36	- var F = arguments[len-1];
37	-
38	- var C = typeof F.initialize == "function" ?
39	- F.initialize :
40	- function(){ P.prototype.initialize.apply(this, arguments); };
41	-
42	- if (len > 1) {
43	- var newArgs = [C, P].concat(
44	- Array.prototype.slice.call(arguments).slice(1, len-1), F);
45	- OpenLayers.inherit.apply(null, newArgs);
46	- } else {
47	- C.prototype = F;
48	- }
49	- return C;
50	-};
51	-
52	-/**
53	- * Property: isPrototype
54	- * Deprecated. This is no longer needed and will be removed at 3.0.
55	- */
56	-OpenLayers.Class.isPrototype = function () {};
57	-
58	-/**
59	- * APIFunction: OpenLayers.create
60	- * Deprecated. Old method to create an OpenLayers style class. Use the
61	- * <OpenLayers.Class> constructor instead.
62	- *
63	- * Returns:
64	- * An OpenLayers class
65	- */
66	-OpenLayers.Class.create = function() {
67	- return function() {
68	- if (arguments && arguments[0] != OpenLayers.Class.isPrototype) {
69	- this.initialize.apply(this, arguments);
70	- }
71	- };
72	-};
73	-
74	-/**
75	- * APIFunction: inherit
76	- * Deprecated. Old method to inherit from one or more OpenLayers style
77	- * classes. Use the <OpenLayers.Class> constructor instead.
78	- *
79	- * Parameters:
80	- * class - One or more classes can be provided as arguments
81	- *
82	- * Returns:
83	- * An object prototype
84	- */
85	-OpenLayers.Class.inherit = function (P) {
86	- var C = function() {
87	- P.call(this);
88	- };
89	- var newArgs = [C].concat(Array.prototype.slice.call(arguments));
90	- OpenLayers.inherit.apply(null, newArgs);
91	- return C.prototype;
92	-};
93	-
94	-/**
95	- * Function: OpenLayers.inherit
96	- *
97	- * Parameters:
98	- * C - {Object} the class that inherits
99	- * P - {Object} the superclass to inherit from
100	- *
101	- * In addition to the mandatory C and P parameters, an arbitrary number of
102	- * objects can be passed, which will extend C.
103	- */
104	-OpenLayers.inherit = function(C, P) {
105	- var F = function() {};
106	- F.prototype = P.prototype;
107	- C.prototype = new F;
108	- var i, l, o;
109	- for(i=2, l=arguments.length; i<l; i++) {
110	- o = arguments[i];
111	- if(typeof o === "function") {
112	- o = o.prototype;
113	- }
114	- OpenLayers.Util.extend(C.prototype, o);
115	- }
116	-};
117	-
118	-/**
119	- * APIFunction: extend
120	- * Copy all properties of a source object to a destination object. Modifies
121	- * the passed in destination object. Any properties on the source object
122	- * that are set to undefined will not be (re)set on the destination object.
123	- *
124	- * Parameters:
125	- * destination - {Object} The object that will be modified
126	- * source - {Object} The object with properties to be set on the destination
127	- *
128	- * Returns:
129	- * {Object} The destination object.
130	- */
131	-OpenLayers.Util = OpenLayers.Util \|\| {};
132	-OpenLayers.Util.extend = function(destination, source) {
133	- destination = destination \|\| {};
134	- if (source) {
135	- for (var property in source) {
136	- var value = source[property];
137	- if (value !== undefined) {
138	- destination[property] = value;
139	- }
140	- }
141	-
142	- /**
143	- * IE doesn't include the toString property when iterating over an object's
144	- * properties with the for(property in object) syntax. Explicitly check if
145	- * the source has its own toString property.
146	- */
147	-
148	- /*
149	- * FF/Windows < 2.0.0.13 reports "Illegal operation on WrappedNative
150	- * prototype object" when calling hawOwnProperty if the source object
151	- * is an instance of window.Event.
152	- */
153	-
154	- var sourceIsEvt = typeof window.Event == "function"
155	- && source instanceof window.Event;
156	-
157	- if (!sourceIsEvt
158	- && source.hasOwnProperty && source.hasOwnProperty("toString")) {
159	- destination.toString = source.toString;
160	- }
161	- }
162	- return destination;
163	-};
	@@ -1,372 +0,0 @@	@@ -1,372 +0,0 @@
1	-/* Copyright (c) 2006-2011 by OpenLayers Contributors (see authors.txt for
2	- * full list of contributors). Published under the Clear BSD license.
3	- * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
4	- * full text of the license. */
5	-
6	-/**
7	- * @requires OpenLayers/BaseTypes/Class.js
8	- * @requires OpenLayers/Console.js
9	- */
10	-
11	-/**
12	- * Class: OpenLayers.Control
13	- * Controls affect the display or behavior of the map. They allow everything
14	- * from panning and zooming to displaying a scale indicator. Controls by
15	- * default are added to the map they are contained within however it is
16	- * possible to add a control to an external div by passing the div in the
17	- * options parameter.
18	- *
19	- * Example:
20	- * The following example shows how to add many of the common controls
21	- * to a map.
22	- *
23	- * > var map = new OpenLayers.Map('map', { controls: [] });
24	- * >
25	- * > map.addControl(new OpenLayers.Control.PanZoomBar());
26	- * > map.addControl(new OpenLayers.Control.MouseToolbar());
27	- * > map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false}));
28	- * > map.addControl(new OpenLayers.Control.Permalink());
29	- * > map.addControl(new OpenLayers.Control.Permalink('permalink'));
30	- * > map.addControl(new OpenLayers.Control.MousePosition());
31	- * > map.addControl(new OpenLayers.Control.OverviewMap());
32	- * > map.addControl(new OpenLayers.Control.KeyboardDefaults());
33	- *
34	- * The next code fragment is a quick example of how to intercept
35	- * shift-mouse click to display the extent of the bounding box
36	- * dragged out by the user. Usually controls are not created
37	- * in exactly this manner. See the source for a more complete
38	- * example:
39	- *
40	- * > var control = new OpenLayers.Control();
41	- * > OpenLayers.Util.extend(control, {
42	- * > draw: function () {
43	- * > // this Handler.Box will intercept the shift-mousedown
44	- * > // before Control.MouseDefault gets to see it
45	- * > this.box = new OpenLayers.Handler.Box( control,
46	- * > {"done": this.notice},
47	- * > {keyMask: OpenLayers.Handler.MOD_SHIFT});
48	- * > this.box.activate();
49	- * > },
50	- * >
51	- * > notice: function (bounds) {
52	- * > OpenLayers.Console.userError(bounds);
53	- * > }
54	- * > });
55	- * > map.addControl(control);
56	- *
57	- */
58	-OpenLayers.Control = OpenLayers.Class({
59	-
60	- /**
61	- * Property: id
62	- * {String}
63	- */
64	- id: null,
65	-
66	- /**
67	- * Property: map
68	- * {<OpenLayers.Map>} this gets set in the addControl() function in
69	- * OpenLayers.Map
70	- */
71	- map: null,
72	-
73	- /**
74	- * APIProperty: div
75	- * {DOMElement} The element that contains the control, if not present the
76	- * control is placed inside the map.
77	- */
78	- div: null,
79	-
80	- /**
81	- * APIProperty: type
82	- * {Number} Controls can have a 'type'. The type determines the type of
83	- * interactions which are possible with them when they are placed in an
84	- * <OpenLayers.Control.Panel>.
85	- */
86	- type: null,
87	-
88	- /**
89	- * Property: allowSelection
90	- * {Boolean} By deafault, controls do not allow selection, because
91	- * it may interfere with map dragging. If this is true, OpenLayers
92	- * will not prevent selection of the control.
93	- * Default is false.
94	- */
95	- allowSelection: false,
96	-
97	- /**
98	- * Property: displayClass
99	- * {string} This property is used for CSS related to the drawing of the
100	- * Control.
101	- */
102	- displayClass: "",
103	-
104	- /**
105	- * APIProperty: title
106	- * {string} This property is used for showing a tooltip over the
107	- * Control.
108	- */
109	- title: "",
110	-
111	- /**
112	- * APIProperty: autoActivate
113	- * {Boolean} Activate the control when it is added to a map. Default is
114	- * false.
115	- */
116	- autoActivate: false,
117	-
118	- /**
119	- * APIProperty: active
120	- * {Boolean} The control is active (read-only). Use <activate> and
121	- * <deactivate> to change control state.
122	- */
123	- active: null,
124	-
125	- /**
126	- * Property: handler
127	- * {<OpenLayers.Handler>} null
128	- */
129	- handler: null,
130	-
131	- /**
132	- * APIProperty: eventListeners
133	- * {Object} If set as an option at construction, the eventListeners
134	- * object will be registered with <OpenLayers.Events.on>. Object
135	- * structure must be a listeners object as shown in the example for
136	- * the events.on method.
137	- */
138	- eventListeners: null,
139	-
140	- /**
141	- * APIProperty: events
142	- * {<OpenLayers.Events>} Events instance for listeners and triggering
143	- * control specific events.
144	- */
145	- events: null,
146	-
147	- /**
148	- * Constant: EVENT_TYPES
149	- * {Array(String)} Supported application event types. Register a listener
150	- * for a particular event with the following syntax:
151	- * (code)
152	- * control.events.register(type, obj, listener);
153	- * (end)
154	- *
155	- * Listeners will be called with a reference to an event object. The
156	- * properties of this event depends on exactly what happened.
157	- *
158	- * All event objects have at least the following properties:
159	- * object - {Object} A reference to control.events.object (a reference
160	- * to the control).
161	- * element - {DOMElement} A reference to control.events.element (which
162	- * will be null unless documented otherwise).
163	- *
164	- * Supported map event types:
165	- * activate - Triggered when activated.
166	- * deactivate - Triggered when deactivated.
167	- */
168	- EVENT_TYPES: ["activate", "deactivate"],
169	-
170	- /**
171	- * Constructor: OpenLayers.Control
172	- * Create an OpenLayers Control. The options passed as a parameter
173	- * directly extend the control. For example passing the following:
174	- *
175	- * > var control = new OpenLayers.Control({div: myDiv});
176	- *
177	- * Overrides the default div attribute value of null.
178	- *
179	- * Parameters:
180	- * options - {Object}
181	- */
182	- initialize: function (options) {
183	- // We do this before the extend so that instances can override
184	- // className in options.
185	- this.displayClass =
186	- this.CLASS_NAME.replace("OpenLayers.", "ol").replace(/\./g, "");
187	-
188	- OpenLayers.Util.extend(this, options);
189	-
190	- this.events = new OpenLayers.Events(this, null, this.EVENT_TYPES);
191	- if(this.eventListeners instanceof Object) {
192	- this.events.on(this.eventListeners);
193	- }
194	- if (this.id == null) {
195	- this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
196	- }
197	- },
198	-
199	- /**
200	- * Method: destroy
201	- * The destroy method is used to perform any clean up before the control
202	- * is dereferenced. Typically this is where event listeners are removed
203	- * to prevent memory leaks.
204	- */
205	- destroy: function () {
206	- if(this.events) {
207	- if(this.eventListeners) {
208	- this.events.un(this.eventListeners);
209	- }
210	- this.events.destroy();
211	- this.events = null;
212	- }
213	- this.eventListeners = null;
214	-
215	- // eliminate circular references
216	- if (this.handler) {
217	- this.handler.destroy();
218	- this.handler = null;
219	- }
220	- if(this.handlers) {
221	- for(var key in this.handlers) {
222	- if(this.handlers.hasOwnProperty(key) &&
223	- typeof this.handlers[key].destroy == "function") {
224	- this.handlers[key].destroy();
225	- }
226	- }
227	- this.handlers = null;
228	- }
229	- if (this.map) {
230	- this.map.removeControl(this);
231	- this.map = null;
232	- }
233	- this.div = null;
234	- },
235	-
236	- /**
237	- * Method: setMap
238	- * Set the map property for the control. This is done through an accessor
239	- * so that subclasses can override this and take special action once
240	- * they have their map variable set.
241	- *
242	- * Parameters:
243	- * map - {<OpenLayers.Map>}
244	- */
245	- setMap: function(map) {
246	- this.map = map;
247	- if (this.handler) {
248	- this.handler.setMap(map);
249	- }
250	- },
251	-
252	- /**
253	- * Method: draw
254	- * The draw method is called when the control is ready to be displayed
255	- * on the page. If a div has not been created one is created. Controls
256	- * with a visual component will almost always want to override this method
257	- * to customize the look of control.
258	- *
259	- * Parameters:
260	- * px - {<OpenLayers.Pixel>} The top-left pixel position of the control
261	- * or null.
262	- *
263	- * Returns:
264	- * {DOMElement} A reference to the DIV DOMElement containing the control
265	- */
266	- draw: function (px) {
267	- if (this.div == null) {
268	- this.div = OpenLayers.Util.createDiv(this.id);
269	- this.div.className = this.displayClass;
270	- if (!this.allowSelection) {
271	- this.div.className += " olControlNoSelect";
272	- this.div.setAttribute("unselectable", "on", 0);
273	- this.div.onselectstart = OpenLayers.Function.False;
274	- }
275	- if (this.title != "") {
276	- this.div.title = this.title;
277	- }
278	- }
279	- if (px != null) {
280	- this.position = px.clone();
281	- }
282	- this.moveTo(this.position);
283	- return this.div;
284	- },
285	-
286	- /**
287	- * Method: moveTo
288	- * Sets the left and top style attributes to the passed in pixel
289	- * coordinates.
290	- *
291	- * Parameters:
292	- * px - {<OpenLayers.Pixel>}
293	- */
294	- moveTo: function (px) {
295	- if ((px != null) && (this.div != null)) {
296	- this.div.style.left = px.x + "px";
297	- this.div.style.top = px.y + "px";
298	- }
299	- },
300	-
301	- /**
302	- * APIMethod: activate
303	- * Explicitly activates a control and it's associated
304	- * handler if one has been set. Controls can be
305	- * deactivated by calling the deactivate() method.
306	- *
307	- * Returns:
308	- * {Boolean} True if the control was successfully activated or
309	- * false if the control was already active.
310	- */
311	- activate: function () {
312	- if (this.active) {
313	- return false;
314	- }
315	- if (this.handler) {
316	- this.handler.activate();
317	- }
318	- this.active = true;
319	- if(this.map) {
320	- OpenLayers.Element.addClass(
321	- this.map.viewPortDiv,
322	- this.displayClass.replace(/ /g, "") + "Active"
323	- );
324	- }
325	- this.events.triggerEvent("activate");
326	- return true;
327	- },
328	-
329	- /**
330	- * APIMethod: deactivate
331	- * Deactivates a control and it's associated handler if any. The exact
332	- * effect of this depends on the control itself.
333	- *
334	- * Returns:
335	- * {Boolean} True if the control was effectively deactivated or false
336	- * if the control was already inactive.
337	- */
338	- deactivate: function () {
339	- if (this.active) {
340	- if (this.handler) {
341	- this.handler.deactivate();
342	- }
343	- this.active = false;
344	- if(this.map) {
345	- OpenLayers.Element.removeClass(
346	- this.map.viewPortDiv,
347	- this.displayClass.replace(/ /g, "") + "Active"
348	- );
349	- }
350	- this.events.triggerEvent("deactivate");
351	- return true;
352	- }
353	- return false;
354	- },
355	-
356	- CLASS_NAME: "OpenLayers.Control"
357	-});
358	-
359	-/**
360	- * Constant: OpenLayers.Control.TYPE_BUTTON
361	- */
362	-OpenLayers.Control.TYPE_BUTTON = 1;
363	-
364	-/**
365	- * Constant: OpenLayers.Control.TYPE_TOGGLE
366	- */
367	-OpenLayers.Control.TYPE_TOGGLE = 2;
368	-
369	-/**
370	- * Constant: OpenLayers.Control.TYPE_TOOL
371	- */
372	-OpenLayers.Control.TYPE_TOOL = 3;
	@@ -1,392 +0,0 @@	@@ -1,392 +0,0 @@
1	-/* Copyright (c) 2006-2011 by OpenLayers Contributors (see authors.txt for
2	- * full list of contributors). Published under the Clear BSD license.
3	- * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
4	- * full text of the license. */
5	-
6	-/**
7	- * @requires OpenLayers/Control.js
8	- */
9	-
10	-/**
11	- * Class: OpenLayers.Control.Panel
12	- * The Panel control is a container for other controls. With it toolbars
13	- * may be composed.
14	- *
15	- * Inherits from:
16	- * - <OpenLayers.Control>
17	- */
18	-OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, {
19	- /**
20	- * Property: controls
21	- * {Array(<OpenLayers.Control>)}
22	- */
23	- controls: null,
24	-
25	- /**
26	- * APIProperty: autoActivate
27	- * {Boolean} Activate the control when it is added to a map. Default is
28	- * true.
29	- */
30	- autoActivate: true,
31	-
32	- /**
33	- * APIProperty: defaultControl
34	- * {<OpenLayers.Control>} The control which is activated when the control is
35	- * activated (turned on), which also happens at instantiation.
36	- * If <saveState> is true, <defaultControl> will be nullified after the
37	- * first activation of the panel.
38	- */
39	- defaultControl: null,
40	-
41	- /**
42	- * APIProperty: saveState
43	- * {Boolean} If set to true, the active state of this panel's controls will
44	- * be stored on panel deactivation, and restored on reactivation. Default
45	- * is false.
46	- */
47	- saveState: false,
48	-
49	- /**
50	- * APIProperty: allowDepress
51	- * {Boolean} If is true the <OpenLayers.Control.TYPE_TOOL> controls can
52	- * be deactivated by clicking the icon that represents them. Default
53	- * is false.
54	- */
55	- allowDepress: false,
56	-
57	- /**
58	- * Property: activeState
59	- * {Object} stores the active state of this panel's controls.
60	- */
61	- activeState: null,
62	-
63	- /**
64	- * Constructor: OpenLayers.Control.Panel
65	- * Create a new control panel.
66	- *
67	- * Each control in the panel is represented by an icon. When clicking
68	- * on an icon, the <activateControl> method is called.
69	- *
70	- * Specific properties for controls on a panel:
71	- * type - {Number} One of <OpenLayers.Control.TYPE_TOOL>,
72	- * <OpenLayers.Control.TYPE_TOGGLE>, <OpenLayers.Control.TYPE_BUTTON>.
73	- * If not provided, <OpenLayers.Control.TYPE_TOOL> is assumed.
74	- * title - {string} Text displayed when mouse is over the icon that
75	- * represents the control.
76	- *
77	- * The <OpenLayers.Control.type> of a control determines the behavior when
78	- * clicking its icon:
79	- * <OpenLayers.Control.TYPE_TOOL> - The control is activated and other
80	- * controls of this type in the same panel are deactivated. This is
81	- * the default type.
82	- * <OpenLayers.Control.TYPE_TOGGLE> - The active state of the control is
83	- * toggled.
84	- * <OpenLayers.Control.TYPE_BUTTON> - The
85	- * <OpenLayers.Control.Button.trigger> method of the control is called,
86	- * but its active state is not changed.
87	- *
88	- * If a control is <OpenLayers.Control.active>, it will be drawn with the
89	- * olControl[Name]ItemActive class, otherwise with the
90	- * olControl[Name]ItemInactive class.
91	- *
92	- * Parameters:
93	- * options - {Object} An optional object whose properties will be used
94	- * to extend the control.
95	- */
96	- initialize: function(options) {
97	- OpenLayers.Control.prototype.initialize.apply(this, [options]);
98	- this.controls = [];
99	- this.activeState = {};
100	- },
101	-
102	- /**
103	- * APIMethod: destroy
104	- */
105	- destroy: function() {
106	- OpenLayers.Control.prototype.destroy.apply(this, arguments);
107	- for (var ctl, i = this.controls.length - 1; i >= 0; i--) {
108	- ctl = this.controls[i];
109	- if (ctl.events) {
110	- ctl.events.un({
111	- activate: this.iconOn,
112	- deactivate: this.iconOff
113	- });
114	- }
115	- OpenLayers.Event.stopObservingElement(ctl.panel_div);
116	- ctl.panel_div = null;
117	- }
118	- this.activeState = null;
119	- },
120	-
121	- /**
122	- * APIMethod: activate
123	- */
124	- activate: function() {
125	- if (OpenLayers.Control.prototype.activate.apply(this, arguments)) {
126	- var control;
127	- for (var i=0, len=this.controls.length; i<len; i++) {
128	- control = this.controls[i];
129	- if (control === this.defaultControl \|\|
130	- (this.saveState && this.activeState[control.id])) {
131	- control.activate();
132	- }
133	- }
134	- if (this.saveState === true) {
135	- this.defaultControl = null;
136	- }
137	- this.redraw();
138	- return true;
139	- } else {
140	- return false;
141	- }
142	- },
143	-
144	- /**
145	- * APIMethod: deactivate
146	- */
147	- deactivate: function() {
148	- if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) {
149	- var control;
150	- for (var i=0, len=this.controls.length; i<len; i++) {
151	- control = this.controls[i];
152	- this.activeState[control.id] = control.deactivate();
153	- }
154	- this.redraw();
155	- return true;
156	- } else {
157	- return false;
158	- }
159	- },
160	-
161	- /**
162	- * Method: draw
163	- *
164	- * Returns:
165	- * {DOMElement}
166	- */
167	- draw: function() {
168	- OpenLayers.Control.prototype.draw.apply(this, arguments);
169	- this.addControlsToMap(this.controls);
170	- return this.div;
171	- },
172	-
173	- /**
174	- * Method: redraw
175	- */
176	- redraw: function() {
177	- for (var l=this.div.childNodes.length, i=l-1; i>=0; i--) {
178	- this.div.removeChild(this.div.childNodes[i]);
179	- }
180	- this.div.innerHTML = "";
181	- if (this.active) {
182	- for (var i=0, len=this.controls.length; i<len; i++) {
183	- this.div.appendChild(this.controls[i].panel_div);
184	- }
185	- }
186	- },
187	-
188	- /**
189	- * APIMethod: activateControl
190	- * This method is called when the user click on the icon representing a
191	- * control in the panel.
192	- *
193	- * Parameters:
194	- * control - {<OpenLayers.Control>}
195	- */
196	- activateControl: function (control) {
197	- if (!this.active) { return false; }
198	- if (control.type == OpenLayers.Control.TYPE_BUTTON) {
199	- control.trigger();
200	- return;
201	- }
202	- if (control.type == OpenLayers.Control.TYPE_TOGGLE) {
203	- if (control.active) {
204	- control.deactivate();
205	- } else {
206	- control.activate();
207	- }
208	- return;
209	- }
210	- if (this.allowDepress && control.active) {
211	- control.deactivate();
212	- } else {
213	- var c;
214	- for (var i=0, len=this.controls.length; i<len; i++) {
215	- c = this.controls[i];
216	- if (c != control &&
217	- (c.type === OpenLayers.Control.TYPE_TOOL \|\| c.type == null)) {
218	- c.deactivate();
219	- }
220	- }
221	- control.activate();
222	- }
223	- },
224	-
225	- /**
226	- * APIMethod: addControls
227	- * To build a toolbar, you add a set of controls to it. addControls
228	- * lets you add a single control or a list of controls to the
229	- * Control Panel.
230	- *
231	- * Parameters:
232	- * controls - {<OpenLayers.Control>} Controls to add in the panel.
233	- */
234	- addControls: function(controls) {
235	- if (!(OpenLayers.Util.isArray(controls))) {
236	- controls = [controls];
237	- }
238	- this.controls = this.controls.concat(controls);
239	-
240	- // Give each control a panel_div which will be used later.
241	- // Access to this div is via the panel_div attribute of the
242	- // control added to the panel.
243	- // Also, stop mousedowns and clicks, but don't stop mouseup,
244	- // since they need to pass through.
245	- for (var i=0, len=controls.length; i<len; i++) {
246	- var element = document.createElement("div");
247	- element.className = controls[i].displayClass + "ItemInactive";
248	- controls[i].panel_div = element;
249	- if (controls[i].title != "") {
250	- controls[i].panel_div.title = controls[i].title;
251	- }
252	- OpenLayers.Event.observe(controls[i].panel_div, "click",
253	- OpenLayers.Function.bind(this.onClick, this, controls[i]));
254	- OpenLayers.Event.observe(controls[i].panel_div, "dblclick",
255	- OpenLayers.Function.bind(this.onDoubleClick, this, controls[i]));
256	- OpenLayers.Event.observe(controls[i].panel_div, "mousedown",
257	- OpenLayers.Function.bindAsEventListener(OpenLayers.Event.stop));
258	- }
259	-
260	- if (this.map) { // map.addControl() has already been called on the panel
261	- this.addControlsToMap(controls);
262	- this.redraw();
263	- }
264	- },
265	-
266	- /**
267	- * Method: addControlsToMap
268	- * Only for internal use in draw() and addControls() methods.
269	- *
270	- * Parameters:
271	- * controls - {Array(<OpenLayers.Control>)} Controls to add into map.
272	- */
273	- addControlsToMap: function (controls) {
274	- var control;
275	- for (var i=0, len=controls.length; i<len; i++) {
276	- control = controls[i];
277	- if (control.autoActivate === true) {
278	- control.autoActivate = false;
279	- this.map.addControl(control);
280	- control.autoActivate = true;
281	- } else {
282	- this.map.addControl(control);
283	- control.deactivate();
284	- }
285	- control.events.on({
286	- activate: this.iconOn,
287	- deactivate: this.iconOff
288	- });
289	- }
290	- },
291	-
292	- /**
293	- * Method: iconOn
294	- * Internal use, for use only with "controls[i].events.on/un".
295	- */
296	- iconOn: function() {
297	- var d = this.panel_div; // "this" refers to a control on panel!
298	- d.className = d.className.replace(/ItemInactive$/, "ItemActive");
299	- },
300	-
301	- /**
302	- * Method: iconOff
303	- * Internal use, for use only with "controls[i].events.on/un".
304	- */
305	- iconOff: function() {
306	- var d = this.panel_div; // "this" refers to a control on panel!
307	- d.className = d.className.replace(/ItemActive$/, "ItemInactive");
308	- },
309	-
310	- /**
311	- * Method: onClick
312	- */
313	- onClick: function (ctrl, evt) {
314	- OpenLayers.Event.stop(evt ? evt : window.event);
315	- this.activateControl(ctrl);
316	- },
317	-
318	- /**
319	- * Method: onDoubleClick
320	- */
321	- onDoubleClick: function(ctrl, evt) {
322	- OpenLayers.Event.stop(evt ? evt : window.event);
323	- },
324	-
325	- /**
326	- * APIMethod: getControlsBy
327	- * Get a list of controls with properties matching the given criteria.
328	- *
329	- * Parameter:
330	- * property - {String} A control property to be matched.
331	- * match - {String \| Object} A string to match. Can also be a regular
332	- * expression literal or object. In addition, it can be any object
333	- * with a method named test. For reqular expressions or other, if
334	- * match.test(control[property]) evaluates to true, the control will be
335	- * included in the array returned. If no controls are found, an empty
336	- * array is returned.
337	- *
338	- * Returns:
339	- * {Array(<OpenLayers.Control>)} A list of controls matching the given criteria.
340	- * An empty array is returned if no matches are found.
341	- */
342	- getControlsBy: function(property, match) {
343	- var test = (typeof match.test == "function");
344	- var found = OpenLayers.Array.filter(this.controls, function(item) {
345	- return item[property] == match \|\| (test && match.test(item[property]));
346	- });
347	- return found;
348	- },
349	-
350	- /**
351	- * APIMethod: getControlsByName
352	- * Get a list of contorls with names matching the given name.
353	- *
354	- * Parameter:
355	- * match - {String \| Object} A control name. The name can also be a regular
356	- * expression literal or object. In addition, it can be any object
357	- * with a method named test. For reqular expressions or other, if
358	- * name.test(control.name) evaluates to true, the control will be included
359	- * in the list of controls returned. If no controls are found, an empty
360	- * array is returned.
361	- *
362	- * Returns:
363	- * {Array(<OpenLayers.Control>)} A list of controls matching the given name.
364	- * An empty array is returned if no matches are found.
365	- */
366	- getControlsByName: function(match) {
367	- return this.getControlsBy("name", match);
368	- },
369	-
370	- /**
371	- * APIMethod: getControlsByClass
372	- * Get a list of controls of a given type (CLASS_NAME).
373	- *
374	- * Parameter:
375	- * match - {String \| Object} A control class name. The type can also be a
376	- * regular expression literal or object. In addition, it can be any
377	- * object with a method named test. For reqular expressions or other,
378	- * if type.test(control.CLASS_NAME) evaluates to true, the control will
379	- * be included in the list of controls returned. If no controls are
380	- * found, an empty array is returned.
381	- *
382	- * Returns:
383	- * {Array(<OpenLayers.Control>)} A list of controls matching the given type.
384	- * An empty array is returned if no matches are found.
385	- */
386	- getControlsByClass: function(match) {
387	- return this.getControlsBy("CLASS_NAME", match);
388	- },
389	-
390	- CLASS_NAME: "OpenLayers.Control.Panel"
391	-});
392	-
	@@ -1,97 +0,0 @@	@@ -1,97 +0,0 @@
1	-var OpenLayers={
2	- VERSION_NUMBER:"Release 2.11",
3	- singleFile:true,
4	- _getScriptLocation:(
5	- function(){
6	- var r=new RegExp("(^\|(.*?\\/))(OpenLayers\.js)(\\?\|$)"),
7	- s=document.getElementsByTagName('script'),
8	- src,
9	- m,
10	- l="";
11	- for(var i=0,len=s.length;i<len;i++){
12	- src=s[i].getAttribute('src');
13	- if(src){
14	- var m=src.match(r);
15	- if(m){
16	- l=m[1];
17	- break;
18	- }
19	- }
20	- }
21	- return(
22	- function(){
23	- return l;
24	- }
25	- );
26	- }
27	- )()
28	-};
29	-OpenLayers.Util = OpenLayers.Util \|\| {};
30	-OpenLayers.Util.lastSeqID = 0;
31	-OpenLayers.Util.isArray = function(a) {
32	- return (Object.prototype.toString.call(a) === '[object Array]');
33	-};
34	-OpenLayers.Util.createUniqueID = function(prefix) {
35	- if (prefix == null) {
36	- prefix = "id_";
37	- }
38	- OpenLayers.Util.lastSeqID += 1;
39	- return prefix + OpenLayers.Util.lastSeqID;
40	-};
41	-OpenLayers.Util.createDiv = function(id, px, sz, imgURL, position,
42	- border, overflow, opacity) {
43	-
44	- var dom = document.createElement('div');
45	-
46	- if (imgURL) {
47	- dom.style.backgroundImage = 'url(' + imgURL + ')';
48	- }
49	-
50	- //set generic properties
51	- if (!id) {
52	- id = OpenLayers.Util.createUniqueID("OpenLayersDiv");
53	- }
54	- if (!position) {
55	- position = "absolute";
56	- }
57	- OpenLayers.Util.modifyDOMElement(dom, id, px, sz, position,
58	- border, overflow, opacity);
59	-
60	- return dom;
61	-};
62	-OpenLayers.Util.modifyDOMElement = function(element, id, px, sz, position,
63	- border, overflow, opacity) {
64	-
65	- if (id) {
66	- element.id = id;
67	- }
68	- if (px) {
69	- element.style.left = px.x + "px";
70	- element.style.top = px.y + "px";
71	- }
72	- if (sz) {
73	- element.style.width = sz.w + "px";
74	- element.style.height = sz.h + "px";
75	- }
76	- if (position) {
77	- element.style.position = position;
78	- }
79	- if (border) {
80	- element.style.border = border;
81	- }
82	- if (overflow) {
83	- element.style.overflow = overflow;
84	- }
85	- if (parseFloat(opacity) >= 0.0 && parseFloat(opacity) < 1.0) {
86	- element.style.filter = 'alpha(opacity=' + (opacity * 100) + ')';
87	- element.style.opacity = opacity;
88	- } else if (parseFloat(opacity) == 1.0) {
89	- element.style.filter = '';
90	- element.style.opacity = '';
91	- }
92	-};
93	-<?php
94	-include("Class.js");
95	-include("Panel.js");
96	-include("Control.js");
97	-?>