/* OpenLayers.js -- OpenLayers Map Viewer Library Copyright 2005-2008 MetaCarta, Inc., released under the Clear BSD license. Please see http://svn.openlayers.org/trunk/openlayers/license.txt for the full text of the license. Includes compressed code under the following licenses: (For uncompressed versions of the code used please see the OpenLayers SVN repository: ) */ /* Contains portions of Prototype.js: * * Prototype JavaScript framework, version 1.4.0 * (c) 2005 Sam Stephenson * * Prototype is freely distributable under the terms of an MIT-style license. * For details, see the Prototype web site: http://prototype.conio.net/ * *--------------------------------------------------------------------------*/ /** * * Contains portions of Rico * * Copyright 2005 Sabre Airline Solutions * * Licensed under the Apache License, Version 2.0 (the "License"); you * may not use this file except in compliance with the License. You * may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or * implied. See the License for the specific language governing * permissions and limitations under the License. * **/ /* ====================================================================== OpenLayers/SingleFile.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ var OpenLayers = { singleFile: true }; /* ====================================================================== OpenLayers.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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/Lang/en.js */ (function() { /** * Before creating the OpenLayers namespace, check to see if * OpenLayers.singleFile is true. This occurs if the * OpenLayers/SingleFile.js script is included before this one - as is the * case with single file builds. */ var singleFile = (typeof OpenLayers == "object" && OpenLayers.singleFile); /** * Namespace: OpenLayers * The OpenLayers object provides a namespace for all things OpenLayers */ window.OpenLayers = { /** * Property: _scriptName * {String} Relative path of this script. */ _scriptName: (!singleFile) ? "lib/OpenLayers.js" : "OpenLayers.js", /** * Function: _getScriptLocation * Return the path to this script. * * Returns: * {String} Path to this script */ _getScriptLocation: function () { var scriptLocation = ""; var scriptName = OpenLayers._scriptName; var scripts = document.getElementsByTagName('script'); for (var i = 0; i < scripts.length; i++) { var src = scripts[i].getAttribute('src'); if (src) { var index = src.lastIndexOf(scriptName); // set path length for src up to a query string var pathLength = src.lastIndexOf('?'); if (pathLength < 0) { pathLength = src.length; } // is it found, at the end of the URL? if ((index > -1) && (index + scriptName.length == pathLength)) { scriptLocation = src.slice(0, pathLength - scriptName.length); break; } } } return scriptLocation; } }; /** * OpenLayers.singleFile is a flag indicating this file is being included * in a Single File Library build of the OpenLayers Library. * * When we are *not* part of a SFL build we dynamically include the * OpenLayers library code. * * When we *are* part of a SFL build we do not dynamically include the * OpenLayers library code as it will be appended at the end of this file. */ if(!singleFile) { var jsfiles = new Array( "OpenLayers/Util.js", "OpenLayers/BaseTypes.js", "OpenLayers/BaseTypes/Class.js", "OpenLayers/BaseTypes/Bounds.js", "OpenLayers/BaseTypes/Element.js", "OpenLayers/BaseTypes/LonLat.js", "OpenLayers/BaseTypes/Pixel.js", "OpenLayers/BaseTypes/Size.js", "OpenLayers/Console.js", "OpenLayers/Tween.js", "Rico/Corner.js", "Rico/Color.js", "OpenLayers/Ajax.js", "OpenLayers/Events.js", "OpenLayers/Projection.js", "OpenLayers/Map.js", "OpenLayers/Layer.js", "OpenLayers/Icon.js", "OpenLayers/Marker.js", "OpenLayers/Marker/Box.js", "OpenLayers/Popup.js", "OpenLayers/Tile.js", "OpenLayers/Tile/Image.js", "OpenLayers/Tile/WFS.js", "OpenLayers/Layer/Image.js", "OpenLayers/Layer/SphericalMercator.js", "OpenLayers/Layer/EventPane.js", "OpenLayers/Layer/FixedZoomLevels.js", "OpenLayers/Layer/Google.js", "OpenLayers/Layer/VirtualEarth.js", "OpenLayers/Layer/Yahoo.js", "OpenLayers/Layer/HTTPRequest.js", "OpenLayers/Layer/Grid.js", "OpenLayers/Layer/MapGuide.js", "OpenLayers/Layer/MapServer.js", "OpenLayers/Layer/MapServer/Untiled.js", "OpenLayers/Layer/KaMap.js", "OpenLayers/Layer/MultiMap.js", "OpenLayers/Layer/Markers.js", "OpenLayers/Layer/Text.js", "OpenLayers/Layer/WorldWind.js", "OpenLayers/Layer/WMS.js", "OpenLayers/Layer/WMS/Untiled.js", "OpenLayers/Layer/GeoRSS.js", "OpenLayers/Layer/Boxes.js", "OpenLayers/Layer/TMS.js", "OpenLayers/Layer/TileCache.js", "OpenLayers/Popup/Anchored.js", "OpenLayers/Popup/AnchoredBubble.js", "OpenLayers/Popup/Framed.js", "OpenLayers/Popup/FramedCloud.js", "OpenLayers/Feature.js", "OpenLayers/Feature/Vector.js", "OpenLayers/Feature/WFS.js", "OpenLayers/Handler.js", "OpenLayers/Handler/Click.js", "OpenLayers/Handler/Hover.js", "OpenLayers/Handler/Point.js", "OpenLayers/Handler/Path.js", "OpenLayers/Handler/Polygon.js", "OpenLayers/Handler/Feature.js", "OpenLayers/Handler/Drag.js", "OpenLayers/Handler/RegularPolygon.js", "OpenLayers/Handler/Box.js", "OpenLayers/Handler/MouseWheel.js", "OpenLayers/Handler/Keyboard.js", "OpenLayers/Control.js", "OpenLayers/Control/Attribution.js", "OpenLayers/Control/Button.js", "OpenLayers/Control/ZoomBox.js", "OpenLayers/Control/ZoomToMaxExtent.js", "OpenLayers/Control/DragPan.js", "OpenLayers/Control/Navigation.js", "OpenLayers/Control/MouseDefaults.js", "OpenLayers/Control/MousePosition.js", "OpenLayers/Control/OverviewMap.js", "OpenLayers/Control/KeyboardDefaults.js", "OpenLayers/Control/PanZoom.js", "OpenLayers/Control/PanZoomBar.js", "OpenLayers/Control/ArgParser.js", "OpenLayers/Control/Permalink.js", "OpenLayers/Control/Scale.js", "OpenLayers/Control/ScaleLine.js", "OpenLayers/Control/LayerSwitcher.js", "OpenLayers/Control/DrawFeature.js", "OpenLayers/Control/DragFeature.js", "OpenLayers/Control/ModifyFeature.js", "OpenLayers/Control/Panel.js", "OpenLayers/Control/SelectFeature.js", "OpenLayers/Control/NavigationHistory.js", "OpenLayers/Geometry.js", "OpenLayers/Geometry/Rectangle.js", "OpenLayers/Geometry/Collection.js", "OpenLayers/Geometry/Point.js", "OpenLayers/Geometry/MultiPoint.js", "OpenLayers/Geometry/Curve.js", "OpenLayers/Geometry/LineString.js", "OpenLayers/Geometry/LinearRing.js", "OpenLayers/Geometry/Polygon.js", "OpenLayers/Geometry/MultiLineString.js", "OpenLayers/Geometry/MultiPolygon.js", "OpenLayers/Geometry/Surface.js", "OpenLayers/Renderer.js", "OpenLayers/Renderer/Elements.js", "OpenLayers/Renderer/SVG.js", "OpenLayers/Renderer/VML.js", "OpenLayers/Layer/Vector.js", "OpenLayers/Layer/PointTrack.js", "OpenLayers/Layer/GML.js", "OpenLayers/Style.js", "OpenLayers/StyleMap.js", "OpenLayers/Rule.js", "OpenLayers/Filter.js", "OpenLayers/Filter/FeatureId.js", "OpenLayers/Filter/Logical.js", "OpenLayers/Filter/Comparison.js", "OpenLayers/Format.js", "OpenLayers/Format/XML.js", "OpenLayers/Format/GML.js", "OpenLayers/Format/KML.js", "OpenLayers/Format/GeoRSS.js", "OpenLayers/Format/WFS.js", "OpenLayers/Format/WKT.js", "OpenLayers/Format/OSM.js", "OpenLayers/Format/SLD.js", "OpenLayers/Format/SLD/v1.js", "OpenLayers/Format/SLD/v1_0_0.js", "OpenLayers/Format/Text.js", "OpenLayers/Format/JSON.js", "OpenLayers/Format/GeoJSON.js", "OpenLayers/Format/WMC.js", "OpenLayers/Format/WMC/v1.js", "OpenLayers/Format/WMC/v1_0_0.js", "OpenLayers/Format/WMC/v1_1_0.js", "OpenLayers/Layer/WFS.js", "OpenLayers/Control/MouseToolbar.js", "OpenLayers/Control/NavToolbar.js", "OpenLayers/Control/EditingToolbar.js", "OpenLayers/Lang.js", "OpenLayers/Lang/en.js" ); // etc. var agent = navigator.userAgent; var docWrite = (agent.match("MSIE") || agent.match("Safari")); if(docWrite) { var allScriptTags = new Array(jsfiles.length); } var host = OpenLayers._getScriptLocation() + "lib/"; for (var i = 0; i < jsfiles.length; i++) { if (docWrite) { allScriptTags[i] = ""; } else { var s = document.createElement("script"); s.src = host + jsfiles[i]; var h = document.getElementsByTagName("head").length ? document.getElementsByTagName("head")[0] : document.body; h.appendChild(s); } } if (docWrite) { document.write(allScriptTags.join("")); } } })(); /** * Constant: VERSION_NUMBER */ OpenLayers.VERSION_NUMBER="$Revision: 6819 $"; /* ====================================================================== OpenLayers/BaseTypes.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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/BaseTypes/LonLat.js * @requires OpenLayers/BaseTypes/Size.js * @requires OpenLayers/BaseTypes/Pixel.js * @requires OpenLayers/BaseTypes/Bounds.js * @requires OpenLayers/BaseTypes/Element.js * @requires OpenLayers/Lang/en.js */ /** * Header: OpenLayers Base Types * OpenLayers custom string, number and function functions are described here. */ /** * Namespace: OpenLayers.String * Contains convenience functions for string manipulation. */ OpenLayers.String = { /** * APIFunction: startsWith * Test whether a string starts with another string. * * Parameters: * str - {String} The string to test. * sub - {Sring} The substring to look for. * * Returns: * {Boolean} The first string starts with the second. */ startsWith: function(str, sub) { return (str.indexOf(sub) == 0); }, /** * APIFunction: contains * Test whether a string contains another string. * * Parameters: * str - {String} The string to test. * sub - {String} The substring to look for. * * Returns: * {Boolean} The first string contains the second. */ contains: function(str, sub) { return (str.indexOf(sub) != -1); }, /** * APIFunction: trim * Removes leading and trailing whitespace characters from a string. * * Parameters: * str - {String} The (potentially) space padded string. This string is not * modified. * * Returns: * {String} A trimmed version of the string with all leading and * trailing spaces removed. */ trim: function(str) { return str.replace(/^\s*(.*?)\s*$/, "$1"); }, /** * APIFunction: camelize * Camel-case a hyphenated string. * Ex. "chicken-head" becomes "chickenHead", and * "-chicken-head" becomes "ChickenHead". * * Parameters: * str - {String} The string to be camelized. The original is not modified. * * Returns: * {String} The string, camelized */ camelize: function(str) { var oStringList = str.split('-'); var camelizedString = oStringList[0]; for (var i = 1; i < oStringList.length; i++) { var s = oStringList[i]; camelizedString += s.charAt(0).toUpperCase() + s.substring(1); } return camelizedString; }, /** * APIFunction: format * Given a string with tokens in the form ${token}, return a string * with tokens replaced with properties from the given context * object. Represent a literal "${" by doubling it, e.g. "${${". * * Parameters: * template - {String} A string with tokens to be replaced. A template * has the form "literal ${token}" where the token will be replaced * by the value of context["token"]. * context - {Object} An optional object with properties corresponding * to the tokens in the format string. If no context is sent, the * window object will be used. * args - {Array} Optional arguments to pass to any functions found in * the context. If a context property is a function, the token * will be replaced by the return from the function called with * these arguments. * * Returns: * {String} A string with tokens replaced from the context object. */ format: function(template, context, args) { if(!context) { context = window; } var tokens = template.split("${"); var item, last, replacement; for(var i=1; i 0) { replacement = context[item.substring(0, last)]; if(typeof replacement == "function") { replacement = args ? replacement.apply(null, args) : replacement(); } tokens[i] = replacement + item.substring(++last); } else { tokens[i] = "${" + item; } } return tokens.join(""); } }; if (!String.prototype.startsWith) { /** * APIMethod: String.startsWith * *Deprecated*. Whether or not a string starts with another string. * * Parameters: * sStart - {Sring} The string we're testing for. * * Returns: * {Boolean} Whether or not this string starts with the string passed in. */ String.prototype.startsWith = function(sStart) { OpenLayers.Console.warn(OpenLayers.i18n("methodDeprecated", {'newMethod':'OpenLayers.String.startsWith'})); return OpenLayers.String.startsWith(this, sStart); }; } if (!String.prototype.contains) { /** * APIMethod: String.contains * *Deprecated*. Whether or not a string contains another string. * * Parameters: * str - {String} The string that we're testing for. * * Returns: * {Boolean} Whether or not this string contains with the string passed in. */ String.prototype.contains = function(str) { OpenLayers.Console.warn(OpenLayers.i18n("methodDeprecated", {'newMethod':'OpenLayers.String.contains'})); return OpenLayers.String.contains(this, str); }; } if (!String.prototype.trim) { /** * APIMethod: String.trim * *Deprecated*. Removes leading and trailing whitespace characters from a string. * * Returns: * {String} A trimmed version of the string - all leading and * trailing spaces removed */ String.prototype.trim = function() { OpenLayers.Console.warn(OpenLayers.i18n("methodDeprecated", {'newMethod':'OpenLayers.String.trim'})); return OpenLayers.String.trim(this); }; } if (!String.prototype.camelize) { /** * APIMethod: String.camelize * *Deprecated*. Camel-case a hyphenated string. * Ex. "chicken-head" becomes "chickenHead", and * "-chicken-head" becomes "ChickenHead". * * Returns: * {String} The string, camelized */ String.prototype.camelize = function() { OpenLayers.Console.warn(OpenLayers.i18n("methodDeprecated", {'newMethod':'OpenLayers.String.camelize'})); return OpenLayers.String.camelize(this); }; } /** * Namespace: OpenLayers.Number * Contains convenience functions for manipulating numbers. */ OpenLayers.Number = { /** * Property: decimalSeparator * Decimal separator to use when formatting numbers. */ decimalSeparator: ".", /** * Property: thousandsSeparator * Thousands separator to use when formatting numbers. */ thousandsSeparator: ",", /** * APIFunction: limitSigDigs * Limit the number of significant digits on a float. * * Parameters: * num - {Float} * sig - {Integer} * * Returns: * {Float} The number, rounded to the specified number of significant * digits. */ limitSigDigs: function(num, sig) { var fig = 0; if (sig > 0) { fig = parseFloat(num.toPrecision(sig)); } return fig; }, /** * APIFunction: format * Formats a number for output. * * Parameters: * num - {Float} * dec - {Integer} Number of decimal places to round to. * Defaults to 0. Set to null to leave decimal places unchanged. * tsep - {String} Thousands separator. * Default is ",". * dsep - {String} Decimal separator. * Default is ".". * * Returns: * {String} A string representing the formatted number. */ format: function(num, dec, tsep, dsep) { dec = (typeof dec != "undefined") ? dec : 0; tsep = (typeof tsep != "undefined") ? tsep : OpenLayers.Number.thousandsSeparator; dsep = (typeof dsep != "undefined") ? dsep : OpenLayers.Number.decimalSeparator; if (dec != null) { num = parseFloat(num.toFixed(dec)); } var parts = num.toString().split("."); if (parts.length == 1 && dec == null) { // integer where we do not want to touch the decimals dec = 0; } var integer = parts[0]; if (tsep) { var thousands = /(-?[0-9]+)([0-9]{3})/; while(thousands.test(integer)) { integer = integer.replace(thousands, "$1" + tsep + "$2"); } } var str; if (dec == 0) { str = integer; } else { var rem = parts.length > 1 ? parts[1] : "0"; if (dec != null) { rem = rem + new Array(dec - rem.length + 1).join("0"); } str = integer + dsep + rem; } return str; } }; if (!Number.prototype.limitSigDigs) { /** * APIMethod: Number.limitSigDigs * *Deprecated*. Limit the number of significant digits on an integer. Does *not* * work with floats! * * Parameters: * sig - {Integer} * * Returns: * {Integer} The number, rounded to the specified number of significant digits. * If null, 0, or negative value passed in, returns 0 */ Number.prototype.limitSigDigs = function(sig) { OpenLayers.Console.warn(OpenLayers.i18n("methodDeprecated", {'newMethod':'OpenLayers.String.limitSigDigs'})); return OpenLayers.Number.limitSigDigs(this, sig); }; } /** * Namespace: OpenLayers.Function * Contains convenience functions for function manipulation. */ OpenLayers.Function = { /** * APIFunction: bind * Bind a function to an object. Method to easily create closures with * 'this' altered. * * Parameters: * func - {Function} Input function. * object - {Object} The object to bind to the input function (as this). * * Returns: * {Function} A closure with 'this' set to the passed in object. */ bind: function(func, object) { // create a reference to all arguments past the second one var args = Array.prototype.slice.apply(arguments, [2]); return function() { // Push on any additional arguments from the actual function call. // These will come after those sent to the bind call. var newArgs = args.concat( Array.prototype.slice.apply(arguments, [0]) ); return func.apply(object, newArgs); }; }, /** * APIFunction: bindAsEventListener * Bind a function to an object, and configure it to receive the event * object as first parameter when called. * * Parameters: * func - {Function} Input function to serve as an event listener. * object - {Object} A reference to this. * * Returns: * {Function} */ bindAsEventListener: function(func, object) { return function(event) { return func.call(object, event || window.event); }; } }; if (!Function.prototype.bind) { /** * APIMethod: Function.bind * *Deprecated*. Bind a function to an object. * Method to easily create closures with 'this' altered. * * Parameters: * object - {Object} the this parameter * * Returns: * {Function} A closure with 'this' altered to the first * argument. */ Function.prototype.bind = function() { OpenLayers.Console.warn(OpenLayers.i18n("methodDeprecated", {'newMethod':'OpenLayers.String.bind'})); // new function takes the same arguments with this function up front Array.prototype.unshift.apply(arguments, [this]); return OpenLayers.Function.bind.apply(null, arguments); }; } if (!Function.prototype.bindAsEventListener) { /** * APIMethod: Function.bindAsEventListener * *Deprecated*. Bind a function to an object, and configure it to receive the * event object as first parameter when called. * * Parameters: * object - {Object} A reference to this. * * Returns: * {Function} */ Function.prototype.bindAsEventListener = function(object) { OpenLayers.Console.warn(OpenLayers.i18n("methodDeprecated", {'newMethod':'OpenLayers.String.bindAsEventListener'})); return OpenLayers.Function.bindAsEventListener(this, object); }; } /** * Namespace: OpenLayers.Array * Contains convenience functions for array manipulation. */ OpenLayers.Array = { /** * APIMethod: filter * Filter an array. Provides the functionality of the * Array.prototype.filter extension to the ECMA-262 standard. Where * available, Array.prototype.filter will be used. * * Based on well known example from http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:filter * * Parameters: * array - {Array} The array to be filtered. This array is not mutated. * Elements added to this array by the callback will not be visited. * callback - {Function} A function that is called for each element in * the array. If this function returns true, the element will be * included in the return. The function will be called with three * arguments: the element in the array, the index of that element, and * the array itself. If the optional caller parameter is specified * the callback will be called with this set to caller. * caller - {Object} Optional object to be set as this when the callback * is called. * * Returns: * {Array} An array of elements from the passed in array for which the * callback returns true. */ filter: function(array, callback, caller) { var selected = []; if (Array.prototype.filter) { selected = array.filter(callback, caller); } else { var len = array.length; if (typeof callback != "function") { throw new TypeError(); } for(var i=0; i var MyClass = OpenLayers.Class(prototype); * * To create a new OpenLayers-style class with multiple inheritance, use the * following syntax: * > var MyClass = OpenLayers.Class(Class1, Class2, prototype); * */ OpenLayers.Class = function() { var Class = function() { /** * This following condition can be removed at 3.0 - this is only for * backwards compatibility while the Class.inherit method is still * in use. So at 3.0, the following three lines would be replaced with * simply: * this.initialize.apply(this, arguments); */ if (arguments && arguments[0] != OpenLayers.Class.isPrototype) { this.initialize.apply(this, arguments); } }; var extended = {}; var parent; for(var i=0; i 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 constructor instead. * * Parameters: * class - One or more classes can be provided as arguments * * Returns: * An object prototype */ OpenLayers.Class.inherit = function () { var superClass = arguments[0]; var proto = new superClass(OpenLayers.Class.isPrototype); for (var i = 1; i < arguments.length; i++) { if (typeof arguments[i] == "function") { var mixin = arguments[i]; arguments[i] = new mixin(OpenLayers.Class.isPrototype); } OpenLayers.Util.extend(proto, arguments[i]); } return proto; }; /* ====================================================================== OpenLayers/Util.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Namespace: Util */ OpenLayers.Util = {}; /** * Function: getElement * This is the old $() from prototype */ OpenLayers.Util.getElement = function() { var elements = []; for (var i = 0; i < arguments.length; i++) { var element = arguments[i]; if (typeof element == 'string') { element = document.getElementById(element); } if (arguments.length == 1) { return element; } elements.push(element); } return elements; }; /** * Maintain $() from prototype */ if ($ == null) { var $ = OpenLayers.Util.getElement; } /** * 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.extend = function(destination, source) { if(destination && 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; }; /** * 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 - {Object} * * Returns: * {Integer} The index at, which the object was found in the array. * If not found, returns -1. */ OpenLayers.Util.indexOf = function(array, obj) { for(var i=0; i < array.length; 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: * id - {String} The element id attribute to set. * px - {} The left and top style position. * sz - {} 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.d * * Note: zIndex is NOT set * * Parameters: * id - {String} An identifier for this element. If no id is * passed an identifier will be created * automatically. * px - {} The element left and top position. * sz - {} 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 - {} The left and top positions. * sz - {} 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. * delayDisplay - {Boolean} If true waits until the image has been * loaded. * opacity - {Float} Fractional value (0.0 - 1.0) * * Returns: * {DOMElement} A DOM Image created with the specified attributes. */ OpenLayers.Util.createImage = function(id, px, sz, imgURL, position, border, opacity, delayDisplay) { if (imgURL && imgURL.substr(-3,3) == 'svg') { var image = document.createElement("embed"); } else { 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: createEmbed * Creates an embed element with specific attribute values. * * Parameters: * id - {String} The id field for the img. If none assigned one will be * automatically generated. * px - {} The left and top positions. * sz - {} 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. * delayDisplay - {Boolean} If true waits until the image has been * loaded. * opacity - {Float} Fractional value (0.0 - 1.0) * * Returns: * {DOMElement} A DOM Image created with the specified attributes. */ OpenLayers.Util.createEmbed = function(id, px, sz, imgURL, position, border, opacity, delayDisplay) { var image = document.createElement("embed"); //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 * * or * * * 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 or * , 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.backgroundColor = null; this.style.display = ""; } }; /** * Property: onImageLoadErrorColor * {String} The color tiles with load errors will turn. * Default is "pink" */ OpenLayers.Util.onImageLoadErrorColor = "pink"; /** * 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) { this.src = this.src; } else { this.style.backgroundColor = OpenLayers.Util.onImageLoadErrorColor; } this.style.display = ""; }; /** * 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 alpha has is necessary and possible, false otherwise. */ OpenLayers.Util.alphaHack = function() { 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) { } return ( filter && (version >= 5.5) && (version < 7) ); }; /** * Function: modifyAlphaImageDiv * * div - {DOMElement} Div containing Alpha-adjusted Image * id - {String} * px - {} * sz - {} * 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, null, 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()) { 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 * * id - {String} * px - {} * sz - {} * imgURL - {String} * position - {String} * border - {String} * sizing {String} 'crop', 'scale', or 'image'. Default is "scale" * delayDisplay{Boolean} * * 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) { /* * 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.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. "key1=value1&key2=value2&key3=value3") * 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 = []; for (var itemIndex=0; itemIndex 0)) { if (!index) { index=0; } if (result[index].childNodes.length > 1) { return result.childNodes[1].nodeValue; } else if (result[index].childNodes.length == 1) { return result[index].firstChild.nodeValue; } } else { return ""; } }; /** * 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); }; /** * Function: rad * * Parameters: * x - {Float} * * Returns: * {Float} */ OpenLayers.Util.rad = function(x) {return x*Math.PI/180;}; /** * Function: distVincenty * * Parameters: * p1 - {} (or any object with both .lat, .lon properties) * p2 - {} (or any object with both .lat, .lon properties) * * Returns: * {Float} */ OpenLayers.Util.distVincenty=function(p1, p2) { var a = 6378137, b = 6356752.3142, f = 1/298.257223563; 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; }; /** * 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 null, query string is taken from 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 || window.location.href; //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; i < pairs.length; ++i) { var keyValue = pairs[i].split('='); if (keyValue[0]) { var key = decodeURIComponent(keyValue[0]); var value = keyValue[1] || ''; //empty string if no value //decode individual values value = value.split(","); for(var j=0; j < value.length; j++) { value[j] = decodeURIComponent(value[j]); } //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 * * * 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 */ 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; /** * Constant: DOTS_PER_INCH * {Integer} 72 (A sensible default) */ OpenLayers.DOTS_PER_INCH = 72; /** * Function: normalzeScale * * 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. */ OpenLayers.Util.getResolutionFromScale = function (scale, units) { if (units == null) { units = "degrees"; } var normScale = OpenLayers.Util.normalizeScale(scale); var 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 * 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: pagePositon * Calculates the position of an element on the page. * * Parameters: * forElement - {DOMElement} * * Returns: * {Array} two item array, L value then T value. */ OpenLayers.Util.pagePosition = function(forElement) { var valueT = 0, valueL = 0; var element = forElement; var child = forElement; while(element) { if(element == document.body) { // FIXME: IE, when passed 'window' as the forElement, treats it as // equal to document.body, but window.style fails, so getStyle // fails, so we are paranoid and check this here. This check should // probably move into element.getStyle in 2.6. if(child && child.style && OpenLayers.Element.getStyle(child, 'position') == 'absolute') { break; } } valueT += element.offsetTop || 0; valueL += element.offsetLeft || 0; child = element; try { // wrapping this in a try/catch because IE chokes on the offsetParent element = element.offsetParent; } catch(e) { OpenLayers.Console.error(OpenLayers.i18n( "pagePositionFailed",{'elemId':element.id})); break; } } element = forElement; while(element) { valueT -= element.scrollTop || 0; valueL -= element.scrollLeft || 0; element = element.parentNode; } return [valueL, valueT]; }; /** * 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 (host, port, etc) for(var key in urlObj1) { if (options.test) { alert(key + "\n1:" + urlObj1[key] + "\n2:" + urlObj2[key]); } var val1 = urlObj1[key]; var val2 = urlObj2[key]; switch(key) { case "args": //do nothing, they'll be treated below break; case "host": case "port": case "protocol": if ((val1 == "") || (val2 == "")) { //these will be blank for relative urls, so no need to // compare them here -- call break. // break; } // otherwise continue with default compare // default: if ( (key != "args") && (urlObj1[key] != urlObj2[key]) ) { return false; } break; } } // 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 || {}; var urlObject = {}; if (options.ignoreCase) { url = url.toLowerCase(); } var a = document.createElement('a'); a.href = url; //host (without port) urlObject.host = a.host; var port = a.port; if (port.length <= 0) { var newHostLength = urlObject.host.length - (port.length); urlObject.host = urlObject.host.substring(0, newHostLength); } //protocol urlObject.protocol = a.protocol; //port urlObject.port = ((port == "80") && (options.ignorePort80)) ? "" : port; //hash urlObject.hash = (options.ignoreHash) ? "" : 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 (this part allows for relative <-> absolute comparison) if ( ((urlObject.protocol == "file:") && (url.indexOf("file:") != -1)) || ((urlObject.protocol != "file:") && (urlObject.host != "")) ) { urlObject.pathname = a.pathname; //Test to see if the pathname includes the arguments (Opera) var qIndex = urlObject.pathname.indexOf("?"); if (qIndex != -1) { urlObject.pathname = urlObject.pathname.substring(0, qIndex); } } else { var relStr = OpenLayers.Util.removeTail(url); var backs = 0; do { var index = relStr.indexOf("../"); if (index == 0) { backs++; relStr = relStr.substr(3); } else if (index >= 0) { var prevChunk = relStr.substr(0,index - 1); var slash = prevChunk.indexOf("/"); prevChunk = (slash != -1) ? prevChunk.substr(0, slash +1) : ""; var postChunk = relStr.substr(index + 3); relStr = prevChunk + postChunk; } } while(index != -1) var windowAnchor = document.createElement("a"); var windowUrl = window.location.href; if (options.ignoreCase) { windowUrl = windowUrl.toLowerCase(); } windowAnchor.href = windowUrl; //set protocol of window urlObject.protocol = windowAnchor.protocol; var splitter = (windowAnchor.pathname.indexOf("/") != -1) ? "/" : "\\"; var dirs = windowAnchor.pathname.split(splitter); dirs.pop(); //remove filename while ((backs > 0) && (dirs.length > 0)) { dirs.pop(); backs--; } relStr = dirs.join("/") + "/"+ relStr; urlObject.pathname = relStr; } if ((urlObject.protocol == "file:") || (urlObject.protocol == "")) { urlObject.host = "localhost"; } 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; }; /** * 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() { var browserName = ""; var ua = navigator.userAgent.toLowerCase(); if ( ua.indexOf( "opera" ) != -1 ) { browserName = "opera"; } else if ( ua.indexOf( "msie" ) != -1 ) { browserName = "msie"; } else if ( ua.indexOf( "safari" ) != -1 ) { browserName = "safari"; } else if ( ua.indexOf( "mozilla" ) != -1 ) { if ( ua.indexOf( "firefox" ) != -1 ) { browserName = "firefox"; } else { browserName = "mozilla"; } } return browserName; }; /** * 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: * 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. * * Returns: * {OpenLayers.Size} */ OpenLayers.Util.getRenderedDimensions = function(contentHTML, size) { var w = h = null; // create temp container div with restricted size var container = document.createElement("div"); container.style.overflow= ""; container.style.position = "absolute"; container.style.left = "-9999px"; //fix a dimension, if specified. if (size) { if (size.w) { w = container.style.width = size.w; } else if (size.h) { h = container.style.height = size.h; } } // create temp content div and assign content var content = document.createElement("div"); content.innerHTML = contentHTML; // add content to restricted container container.appendChild(content); // append container to body for rendering document.body.appendChild(container); // 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); document.body.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; }; /* ====================================================================== Rico/Corner.js ====================================================================== */ /* * This file has been edited substantially from the Rico-released * version by the OpenLayers development team. * * Copyright 2005 Sabre Airline Solutions * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the * License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, * either express or * implied. See the License for the specific language governing * permissions * and limitations under the License. * */ OpenLayers.Rico = new Object(); OpenLayers.Rico.Corner = { round: function(e, options) { e = OpenLayers.Util.getElement(e); this._setOptions(options); var color = this.options.color; if ( this.options.color == "fromElement" ) { color = this._background(e); } var bgColor = this.options.bgColor; if ( this.options.bgColor == "fromParent" ) { bgColor = this._background(e.offsetParent); } this._roundCornersImpl(e, color, bgColor); }, /** This is a helper function to change the background * color of
that has had Rico rounded corners added. * * It seems we cannot just set the background color for the * outer
so each element used to create the * corners must have its background color set individually. * * @param {DOM} theDiv - A child of the outer
that was * supplied to the `round` method. * * @param {String} newColor - The new background color to use. */ changeColor: function(theDiv, newColor) { theDiv.style.backgroundColor = newColor; var spanElements = theDiv.parentNode.getElementsByTagName("span"); for (var currIdx = 0; currIdx < spanElements.length; currIdx++) { spanElements[currIdx].style.backgroundColor = newColor; } }, /** This is a helper function to change the background * opacity of
that has had Rico rounded corners added. * * See changeColor (above) for algorithm explanation * * @param {DOM} theDiv A child of the outer
that was * supplied to the `round` method. * * @param {int} newOpacity The new opacity to use (0-1). */ changeOpacity: function(theDiv, newOpacity) { var mozillaOpacity = newOpacity; var ieOpacity = 'alpha(opacity=' + newOpacity * 100 + ')'; theDiv.style.opacity = mozillaOpacity; theDiv.style.filter = ieOpacity; var spanElements = theDiv.parentNode.getElementsByTagName("span"); for (var currIdx = 0; currIdx < spanElements.length; currIdx++) { spanElements[currIdx].style.opacity = mozillaOpacity; spanElements[currIdx].style.filter = ieOpacity; } }, /** this function takes care of redoing the rico cornering * * you can't just call updateRicoCorners() again and pass it a * new options string. you have to first remove the divs that * rico puts on top and below the content div. * * @param {DOM} theDiv - A child of the outer
that was * supplied to the `round` method. * * @param {Object} options - list of options */ reRound: function(theDiv, options) { var topRico = theDiv.parentNode.childNodes[0]; //theDiv would be theDiv.parentNode.childNodes[1] var bottomRico = theDiv.parentNode.childNodes[2]; theDiv.parentNode.removeChild(topRico); theDiv.parentNode.removeChild(bottomRico); this.round(theDiv.parentNode, options); }, _roundCornersImpl: function(e, color, bgColor) { if(this.options.border) { this._renderBorder(e,bgColor); } if(this._isTopRounded()) { this._roundTopCorners(e,color,bgColor); } if(this._isBottomRounded()) { this._roundBottomCorners(e,color,bgColor); } }, _renderBorder: function(el,bgColor) { var borderValue = "1px solid " + this._borderColor(bgColor); var borderL = "border-left: " + borderValue; var borderR = "border-right: " + borderValue; var style = "style='" + borderL + ";" + borderR + "'"; el.innerHTML = "
" + el.innerHTML + "
"; }, _roundTopCorners: function(el, color, bgColor) { var corner = this._createCorner(bgColor); for(var i=0 ; i < this.options.numSlices ; i++ ) { corner.appendChild(this._createCornerSlice(color,bgColor,i,"top")); } el.style.paddingTop = 0; el.insertBefore(corner,el.firstChild); }, _roundBottomCorners: function(el, color, bgColor) { var corner = this._createCorner(bgColor); for(var i=(this.options.numSlices-1) ; i >= 0 ; i-- ) { corner.appendChild(this._createCornerSlice(color,bgColor,i,"bottom")); } el.style.paddingBottom = 0; el.appendChild(corner); }, _createCorner: function(bgColor) { var corner = document.createElement("div"); corner.style.backgroundColor = (this._isTransparent() ? "transparent" : bgColor); return corner; }, _createCornerSlice: function(color,bgColor, n, position) { var slice = document.createElement("span"); var inStyle = slice.style; inStyle.backgroundColor = color; inStyle.display = "block"; inStyle.height = "1px"; inStyle.overflow = "hidden"; inStyle.fontSize = "1px"; var borderColor = this._borderColor(color,bgColor); if ( this.options.border && n == 0 ) { inStyle.borderTopStyle = "solid"; inStyle.borderTopWidth = "1px"; inStyle.borderLeftWidth = "0px"; inStyle.borderRightWidth = "0px"; inStyle.borderBottomWidth = "0px"; inStyle.height = "0px"; // assumes css compliant box model inStyle.borderColor = borderColor; } else if(borderColor) { inStyle.borderColor = borderColor; inStyle.borderStyle = "solid"; inStyle.borderWidth = "0px 1px"; } if ( !this.options.compact && (n == (this.options.numSlices-1)) ) { inStyle.height = "2px"; } this._setMargin(slice, n, position); this._setBorder(slice, n, position); return slice; }, _setOptions: function(options) { this.options = { corners : "all", color : "fromElement", bgColor : "fromParent", blend : true, border : false, compact : false }; OpenLayers.Util.extend(this.options, options || {}); this.options.numSlices = this.options.compact ? 2 : 4; if ( this._isTransparent() ) { this.options.blend = false; } }, _whichSideTop: function() { if ( this._hasString(this.options.corners, "all", "top") ) { return ""; } if ( this.options.corners.indexOf("tl") >= 0 && this.options.corners.indexOf("tr") >= 0 ) { return ""; } if (this.options.corners.indexOf("tl") >= 0) { return "left"; } else if (this.options.corners.indexOf("tr") >= 0) { return "right"; } return ""; }, _whichSideBottom: function() { if ( this._hasString(this.options.corners, "all", "bottom") ) { return ""; } if ( this.options.corners.indexOf("bl")>=0 && this.options.corners.indexOf("br")>=0 ) { return ""; } if(this.options.corners.indexOf("bl") >=0) { return "left"; } else if(this.options.corners.indexOf("br")>=0) { return "right"; } return ""; }, _borderColor : function(color,bgColor) { if ( color == "transparent" ) { return bgColor; } else if ( this.options.border ) { return this.options.border; } else if ( this.options.blend ) { return this._blend( bgColor, color ); } else { return ""; } }, _setMargin: function(el, n, corners) { var marginSize = this._marginSize(n); var whichSide = corners == "top" ? this._whichSideTop() : this._whichSideBottom(); if ( whichSide == "left" ) { el.style.marginLeft = marginSize + "px"; el.style.marginRight = "0px"; } else if ( whichSide == "right" ) { el.style.marginRight = marginSize + "px"; el.style.marginLeft = "0px"; } else { el.style.marginLeft = marginSize + "px"; el.style.marginRight = marginSize + "px"; } }, _setBorder: function(el,n,corners) { var borderSize = this._borderSize(n); var whichSide = corners == "top" ? this._whichSideTop() : this._whichSideBottom(); if ( whichSide == "left" ) { el.style.borderLeftWidth = borderSize + "px"; el.style.borderRightWidth = "0px"; } else if ( whichSide == "right" ) { el.style.borderRightWidth = borderSize + "px"; el.style.borderLeftWidth = "0px"; } else { el.style.borderLeftWidth = borderSize + "px"; el.style.borderRightWidth = borderSize + "px"; } if (this.options.border != false) { el.style.borderLeftWidth = borderSize + "px"; el.style.borderRightWidth = borderSize + "px"; } }, _marginSize: function(n) { if ( this._isTransparent() ) { return 0; } var marginSizes = [ 5, 3, 2, 1 ]; var blendedMarginSizes = [ 3, 2, 1, 0 ]; var compactMarginSizes = [ 2, 1 ]; var smBlendedMarginSizes = [ 1, 0 ]; if ( this.options.compact && this.options.blend ) { return smBlendedMarginSizes[n]; } else if ( this.options.compact ) { return compactMarginSizes[n]; } else if ( this.options.blend ) { return blendedMarginSizes[n]; } else { return marginSizes[n]; } }, _borderSize: function(n) { var transparentBorderSizes = [ 5, 3, 2, 1 ]; var blendedBorderSizes = [ 2, 1, 1, 1 ]; var compactBorderSizes = [ 1, 0 ]; var actualBorderSizes = [ 0, 2, 0, 0 ]; if ( this.options.compact && (this.options.blend || this._isTransparent()) ) { return 1; } else if ( this.options.compact ) { return compactBorderSizes[n]; } else if ( this.options.blend ) { return blendedBorderSizes[n]; } else if ( this.options.border ) { return actualBorderSizes[n]; } else if ( this._isTransparent() ) { return transparentBorderSizes[n]; } return 0; }, _hasString: function(str) { for(var i=1 ; i= 0) { return true; } return false; }, _blend: function(c1, c2) { var cc1 = OpenLayers.Rico.Color.createFromHex(c1); cc1.blend(OpenLayers.Rico.Color.createFromHex(c2)); return cc1; }, _background: function(el) { try { return OpenLayers.Rico.Color.createColorFromBackground(el).asHex(); } catch(err) { return "#ffffff"; } }, _isTransparent: function() { return this.options.color == "transparent"; }, _isTopRounded: function() { return this._hasString(this.options.corners, "all", "top", "tl", "tr"); }, _isBottomRounded: function() { return this._hasString(this.options.corners, "all", "bottom", "bl", "br"); }, _hasSingleTextChild: function(el) { return el.childNodes.length == 1 && el.childNodes[0].nodeType == 3; } }; /* ====================================================================== OpenLayers/Ajax.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ OpenLayers.ProxyHost = ""; //OpenLayers.ProxyHost = "examples/proxy.cgi?url="; /** * Ajax reader for OpenLayers * * @uri url to do remote XML http get * @param {String} 'get' format params (x=y&a=b...) * @who object to handle callbacks for this request * @complete the function to be called on success * @failure the function to be called on failure * * example usage from a caller: * * caps: function(request) { * -blah- * }, * * OpenLayers.loadURL(url,params,this,caps); * * Notice the above example does not provide an error handler; a default empty * handler is provided which merely logs the error if a failure handler is not * supplied * */ /** * @param {} request */ OpenLayers.nullHandler = function(request) { alert(OpenLayers.i18n("unhandledRequest", {'statusText':request.statusText})); }; /** * Function: loadURL * Background load a document. * * Parameters: * uri - {String} URI of source doc * params - {String} Params on get (doesnt seem to work) * caller - {Object} object which gets callbacks * onComplete - {Function} Optional callback for success. The callback * will be called with this set to caller and will receive the request * object as an argument. * onFailure - {Function} Optional callback for failure. In the event of * a failure, the callback will be called with this set to caller and will * receive the request object as an argument. * * Returns: * {XMLHttpRequest} The request object. To abort loading, call * request.abort(). */ OpenLayers.loadURL = function(uri, params, caller, onComplete, onFailure) { var success = (onComplete) ? OpenLayers.Function.bind(onComplete, caller) : OpenLayers.nullHandler; var failure = (onFailure) ? OpenLayers.Function.bind(onFailure, caller) : OpenLayers.nullHandler; // from prototype.js var request = new OpenLayers.Ajax.Request( uri, { method: 'get', parameters: params, onComplete: success, onFailure: failure } ); return request.transport; }; /** * Function: parseXMLString * Parse XML into a doc structure * * Parameters: * text - {String} * * Returns: * {?} Parsed AJAX Responsev */ OpenLayers.parseXMLString = function(text) { //MS sucks, if the server is bad it dies var index = text.indexOf('<'); if (index > 0) { text = text.substring(index); } var ajaxResponse = OpenLayers.Util.Try( function() { var xmldom = new ActiveXObject('Microsoft.XMLDOM'); xmldom.loadXML(text); return xmldom; }, function() { return new DOMParser().parseFromString(text, 'text/xml'); }, function() { var req = new XMLHttpRequest(); req.open("GET", "data:" + "text/xml" + ";charset=utf-8," + encodeURIComponent(text), false); if (req.overrideMimeType) { req.overrideMimeType("text/xml"); } req.send(null); return req.responseXML; } ); return ajaxResponse; }; /** * Namespace: OpenLayers.Ajax */ OpenLayers.Ajax = { /** * Method: emptyFunction */ emptyFunction: function () {}, /** * Method: getTransport * * Returns: * {Object} Transport mechanism for whichever browser we're in, or false if * none available. */ getTransport: function() { return OpenLayers.Util.Try( function() {return new XMLHttpRequest();}, function() {return new ActiveXObject('Msxml2.XMLHTTP');}, function() {return new ActiveXObject('Microsoft.XMLHTTP');} ) || false; }, /** * Property: activeRequestCount * {Integer} */ activeRequestCount: 0 }; /** * Namespace: OpenLayers.Ajax.Responders * {Object} */ OpenLayers.Ajax.Responders = { /** * Property: responders * {Array} */ responders: [], /** * Method: register * * Parameters: * responderToAdd - {?} */ register: function(responderToAdd) { for (var i = 0; i < this.responders.length; i++){ if (responderToAdd == this.responders[i]){ return; } } this.responders.push(responderToAdd); }, /** * Method: unregister * * Parameters: * responderToRemove - {?} */ unregister: function(responderToRemove) { OpenLayers.Util.removeItem(this.reponders, responderToRemove); }, /** * Method: dispatch * * Parameters: * callback - {?} * request - {?} * transport - {?} */ dispatch: function(callback, request, transport) { var responder; for (var i = 0; i < this.responders.length; i++) { responder = this.responders[i]; if (responder[callback] && typeof responder[callback] == 'function') { try { responder[callback].apply(responder, [request, transport]); } catch (e) {} } } } }; OpenLayers.Ajax.Responders.register({ /** * Function: onCreate */ onCreate: function() { OpenLayers.Ajax.activeRequestCount++; }, /** * Function: onComplete */ onComplete: function() { OpenLayers.Ajax.activeRequestCount--; } }); /** * Class: OpenLayers.Ajax.Base */ OpenLayers.Ajax.Base = OpenLayers.Class({ /** * Constructor: OpenLayers.Ajax.Base * * Parameters: * options - {Object} */ initialize: function(options) { this.options = { method: 'post', asynchronous: true, contentType: 'application/xml', parameters: '' }; OpenLayers.Util.extend(this.options, options || {}); this.options.method = this.options.method.toLowerCase(); if (typeof this.options.parameters == 'string') { this.options.parameters = OpenLayers.Util.getParameters(this.options.parameters); } } }); /** * Class: OpenLayers.Ajax.Request * * Inherit: * - */ OpenLayers.Ajax.Request = OpenLayers.Class(OpenLayers.Ajax.Base, { /** * Property: _complete * * {Boolean} */ _complete: false, /** * Constructor: OpenLayers.Ajax.Request * * Parameters: * url - {String} * options - {Object} */ initialize: function(url, options) { OpenLayers.Ajax.Base.prototype.initialize.apply(this, [options]); if (OpenLayers.ProxyHost && OpenLayers.String.startsWith(url, "http")) { url = OpenLayers.ProxyHost + encodeURIComponent(url); } this.transport = OpenLayers.Ajax.getTransport(); this.request(url); }, /** * Method: request * * Parameters: * url - {String} */ request: function(url) { this.url = url; this.method = this.options.method; var params = OpenLayers.Util.extend({}, this.options.parameters); if (this.method != 'get' && this.method != 'post') { // simulate other verbs over post params['_method'] = this.method; this.method = 'post'; } this.parameters = params; if (params = OpenLayers.Util.getParameterString(params)) { // when GET, append parameters to URL if (this.method == 'get') { this.url += ((this.url.indexOf('?') > -1) ? '&' : '?') + params; } else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) { params += '&_='; } } try { var response = new OpenLayers.Ajax.Response(this); if (this.options.onCreate) { this.options.onCreate(response); } OpenLayers.Ajax.Responders.dispatch('onCreate', this, response); this.transport.open(this.method.toUpperCase(), this.url, this.options.asynchronous); if (this.options.asynchronous) { window.setTimeout( OpenLayers.Function.bind(this.respondToReadyState, this, 1), 10); } this.transport.onreadystatechange = OpenLayers.Function.bind(this.onStateChange, this); this.setRequestHeaders(); this.body = this.method == 'post' ? (this.options.postBody || params) : null; this.transport.send(this.body); // Force Firefox to handle ready state 4 for synchronous requests if (!this.options.asynchronous && this.transport.overrideMimeType) { this.onStateChange(); } } catch (e) { this.dispatchException(e); } }, /** * Method: onStateChange */ onStateChange: function() { var readyState = this.transport.readyState; if (readyState > 1 && !((readyState == 4) && this._complete)) { this.respondToReadyState(this.transport.readyState); } }, /** * Method: setRequestHeaders */ setRequestHeaders: function() { var headers = { 'X-Requested-With': 'XMLHttpRequest', 'Accept': 'text/javascript, text/html, application/xml, text/xml, */*', 'OpenLayers': true }; if (this.method == 'post') { headers['Content-type'] = this.options.contentType + (this.options.encoding ? '; charset=' + this.options.encoding : ''); /* Force "Connection: close" for older Mozilla browsers to work * around a bug where XMLHttpRequest sends an incorrect * Content-length header. See Mozilla Bugzilla #246651. */ if (this.transport.overrideMimeType && (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005) { headers['Connection'] = 'close'; } } // user-defined headers if (typeof this.options.requestHeaders == 'object') { var extras = this.options.requestHeaders; if (typeof extras.push == 'function') { for (var i = 0, length = extras.length; i < length; i += 2) { headers[extras[i]] = extras[i+1]; } } else { for (var i in extras) { headers[i] = pair[i]; } } } for (var name in headers) { this.transport.setRequestHeader(name, headers[name]); } }, /** * Method: success * * Returns: * {Boolean} - */ success: function() { var status = this.getStatus(); return !status || (status >=200 && status < 300); }, /** * Method: getStatus * * Returns: * {Integer} - Status */ getStatus: function() { try { return this.transport.status || 0; } catch (e) { return 0; } }, /** * Method: respondToReadyState * * Parameters: * readyState - {?} */ respondToReadyState: function(readyState) { var state = OpenLayers.Ajax.Request.Events[readyState]; var response = new OpenLayers.Ajax.Response(this); if (state == 'Complete') { try { this._complete = true; (this.options['on' + response.status] || this.options['on' + (this.success() ? 'Success' : 'Failure')] || OpenLayers.Ajax.emptyFunction)(response); } catch (e) { this.dispatchException(e); } var contentType = response.getHeader('Content-type'); } try { (this.options['on' + state] || OpenLayers.Ajax.emptyFunction)(response); OpenLayers.Ajax.Responders.dispatch('on' + state, this, response); } catch (e) { this.dispatchException(e); } if (state == 'Complete') { // avoid memory leak in MSIE: clean up this.transport.onreadystatechange = OpenLayers.Ajax.emptyFunction; } }, /** * Method: getHeader * * Parameters: * name - {String} Header name * * Returns: * {?} - response header for the given name */ getHeader: function(name) { try { return this.transport.getResponseHeader(name); } catch (e) { return null; } }, /** * Method: dispatchException * If the optional onException function is set, execute it * and then dispatch the call to any other listener registered * for onException. * * If no optional onException function is set, we suspect that * the user may have also not used * OpenLayers.Ajax.Responders.register to register a listener * for the onException call. To make sure that something * gets done with this exception, only dispatch the call if there * are listeners. * * If you explicitly want to swallow exceptions, set * request.options.onException to an empty function (function(){}) * or register an empty function with * for onException. * * Parameters: * exception - {?} */ dispatchException: function(exception) { var handler = this.options.onException; if(handler) { // call options.onException and alert any other listeners handler(this, exception); OpenLayers.Ajax.Responders.dispatch('onException', this, exception); } else { // check if there are any other listeners var listener = false; var responders = OpenLayers.Ajax.Responders.responders; for (var i = 0; i < responders.length; i++) { if(responders[i].onException) { listener = true; break; } } if(listener) { // call all listeners OpenLayers.Ajax.Responders.dispatch('onException', this, exception); } else { // let the exception through throw exception; } } } }); /** * Property: Events * {Array(String)} */ OpenLayers.Ajax.Request.Events = ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete']; /** * Class: OpenLayers.Ajax.Response */ OpenLayers.Ajax.Response = OpenLayers.Class({ /** * Property: status * * {Integer} */ status: 0, /** * Property: statusText * * {String} */ statusText: '', /** * Constructor: OpenLayers.Ajax.Response * * Parameters: * request - {Object} */ initialize: function(request) { this.request = request; var transport = this.transport = request.transport, readyState = this.readyState = transport.readyState; if ((readyState > 2 && !(!!(window.attachEvent && !window.opera))) || readyState == 4) { this.status = this.getStatus(); this.statusText = this.getStatusText(); this.responseText = transport.responseText == null ? '' : String(transport.responseText); } if(readyState == 4) { var xml = transport.responseXML; this.responseXML = xml === undefined ? null : xml; } }, /** * Method: getStatus */ getStatus: OpenLayers.Ajax.Request.prototype.getStatus, /** * Method: getStatustext * * Returns: * {String} - statusText */ getStatusText: function() { try { return this.transport.statusText || ''; } catch (e) { return ''; } }, /** * Method: getHeader */ getHeader: OpenLayers.Ajax.Request.prototype.getHeader, /** * Method: getResponseHeader * * Returns: * {?} - response header for given name */ getResponseHeader: function(name) { return this.transport.getResponseHeader(name); } }); /** * Function: getElementsByTagNameNS * * Parameters: * parentnode - {?} * nsuri - {?} * nsprefix - {?} * tagname - {?} * * Returns: * {?} */ OpenLayers.Ajax.getElementsByTagNameNS = function(parentnode, nsuri, nsprefix, tagname) { var elem = null; if (parentnode.getElementsByTagNameNS) { elem = parentnode.getElementsByTagNameNS(nsuri, tagname); } else { elem = parentnode.getElementsByTagName(nsprefix + ':' + tagname); } return elem; }; /** * Function: serializeXMLToString * Wrapper function around XMLSerializer, which doesn't exist/work in * IE/Safari. We need to come up with a way to serialize in those browser: * for now, these browsers will just fail. #535, #536 * * Parameters: * xmldom {XMLNode} xml dom to serialize * * Returns: * {?} */ OpenLayers.Ajax.serializeXMLToString = function(xmldom) { var serializer = new XMLSerializer(); var data = serializer.serializeToString(xmldom); return data; }; /* ====================================================================== OpenLayers/BaseTypes/Bounds.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Class: OpenLayers.Bounds * Instances of this class represent bounding boxes. Data stored as left, * bottom, right, top floats. All values are initialized to null, however, * you should make sure you set them before using the bounds for anything. * * Possible use case: * > bounds = new OpenLayers.Bounds(); * > bounds.extend(new OpenLayers.LonLat(4,5)); * > bounds.extend(new OpenLayers.LonLat(5,6)); * > bounds.toBBOX(); // returns 4,5,5,6 */ OpenLayers.Bounds = OpenLayers.Class({ /** * Property: left * {Number} Minimum horizontal coordinate. */ left: null, /** * Property: bottom * {Number} Minimum vertical coordinate. */ bottom: null, /** * Property: right * {Number} Maximum horizontal coordinate. */ right: null, /** * Property: top * {Number} Maximum vertical coordinate. */ top: null, /** * Constructor: OpenLayers.Bounds * Construct a new bounds object. * * Parameters: * left - {Number} The left bounds of the box. Note that for width * calculations, this is assumed to be less than the right value. * bottom - {Number} The bottom bounds of the box. Note that for height * calculations, this is assumed to be more than the top value. * right - {Number} The right bounds. * top - {Number} The top bounds. */ initialize: function(left, bottom, right, top) { if (left != null) { this.left = parseFloat(left); } if (bottom != null) { this.bottom = parseFloat(bottom); } if (right != null) { this.right = parseFloat(right); } if (top != null) { this.top = parseFloat(top); } }, /** * Method: clone * Create a cloned instance of this bounds. * * Returns: * {} A fresh copy of the bounds */ clone:function() { return new OpenLayers.Bounds(this.left, this.bottom, this.right, this.top); }, /** * Method: equals * Test a two bounds for equivalence. * * Parameters: * bounds - {} * * Returns: * {Boolean} The passed-in bounds object has the same left, * right, top, bottom components as this. Note that if bounds * passed in is null, returns false. */ equals:function(bounds) { var equals = false; if (bounds != null) { equals = ((this.left == bounds.left) && (this.right == bounds.right) && (this.top == bounds.top) && (this.bottom == bounds.bottom)); } return equals; }, /** * APIMethod: toString * * Returns: * {String} String representation of bounds object. * (ex."left-bottom=(5,42) right-top=(10,45)") */ toString:function() { return ( "left-bottom=(" + this.left + "," + this.bottom + ")" + " right-top=(" + this.right + "," + this.top + ")" ); }, /** * APIMethod: toArray * * Returns: * {Array} array of left, bottom, right, top */ toArray: function() { return [this.left, this.bottom, this.right, this.top]; }, /** * APIMethod: toBBOX * * Parameters: * decimal - {Integer} How many significant digits in the bbox coords? * Default is 6 * * Returns: * {String} Simple String representation of bounds object. * (ex. "5,42,10,45") */ toBBOX:function(decimal) { if (decimal== null) { decimal = 6; } var mult = Math.pow(10, decimal); var bbox = Math.round(this.left * mult) / mult + "," + Math.round(this.bottom * mult) / mult + "," + Math.round(this.right * mult) / mult + "," + Math.round(this.top * mult) / mult; return bbox; }, /** * APIMethod: toGeometry * Create a new polygon geometry based on this bounds. * * Returns: * {} A new polygon with the coordinates * of this bounds. */ toGeometry: function() { return new OpenLayers.Geometry.Polygon([ new OpenLayers.Geometry.LinearRing([ new OpenLayers.Geometry.Point(this.left, this.bottom), new OpenLayers.Geometry.Point(this.right, this.bottom), new OpenLayers.Geometry.Point(this.right, this.top), new OpenLayers.Geometry.Point(this.left, this.top) ]) ]); }, /** * APIMethod: getWidth * * Returns: * {Float} The width of the bounds */ getWidth:function() { return (this.right - this.left); }, /** * APIMethod: getHeight * * Returns: * {Float} The height of the bounds (top minus bottom). */ getHeight:function() { return (this.top - this.bottom); }, /** * APIMethod: getSize * * Returns: * {} The size of the box. */ getSize:function() { return new OpenLayers.Size(this.getWidth(), this.getHeight()); }, /** * APIMethod: getCenterPixel * * Returns: * {} The center of the bounds in pixel space. */ getCenterPixel:function() { return new OpenLayers.Pixel( (this.left + this.right) / 2, (this.bottom + this.top) / 2); }, /** * APIMethod: getCenterLonLat * * Returns: * {} The center of the bounds in map space. */ getCenterLonLat:function() { return new OpenLayers.LonLat( (this.left + this.right) / 2, (this.bottom + this.top) / 2); }, /** * APIMethod: add * * Parameters: * x - {Float} * y - {Float} * * Returns: * {} A new bounds whose coordinates are the same as * this, but shifted by the passed-in x and y values. */ add:function(x, y) { if ( (x == null) || (y == null) ) { var msg = OpenLayers.i18n("boundsAddError"); OpenLayers.Console.error(msg); return null; } return new OpenLayers.Bounds(this.left + x, this.bottom + y, this.right + x, this.top + y); }, /** * APIMethod: extend * Extend the bounds to include the point, lonlat, or bounds specified. * Note, this function assumes that left < right and bottom < top. * * Parameters: * object - {Object} Can be LonLat, Point, or Bounds */ extend:function(object) { var bounds = null; if (object) { switch(object.CLASS_NAME) { case "OpenLayers.LonLat": bounds = new OpenLayers.Bounds(object.lon, object.lat, object.lon, object.lat); break; case "OpenLayers.Geometry.Point": bounds = new OpenLayers.Bounds(object.x, object.y, object.x, object.y); break; case "OpenLayers.Bounds": bounds = object; break; } if (bounds) { if ( (this.left == null) || (bounds.left < this.left)) { this.left = bounds.left; } if ( (this.bottom == null) || (bounds.bottom < this.bottom) ) { this.bottom = bounds.bottom; } if ( (this.right == null) || (bounds.right > this.right) ) { this.right = bounds.right; } if ( (this.top == null) || (bounds.top > this.top) ) { this.top = bounds.top; } } } }, /** * APIMethod: containsLonLat * * Parameters: * ll - {} * inclusive - {Boolean} Whether or not to include the border. * Default is true. * * Returns: * {Boolean} The passed-in lonlat is within this bounds. */ containsLonLat:function(ll, inclusive) { return this.contains(ll.lon, ll.lat, inclusive); }, /** * APIMethod: containsPixel * * Parameters: * px - {} * inclusive - {Boolean} Whether or not to include the border. Default is * true. * * Returns: * {Boolean} The passed-in pixel is within this bounds. */ containsPixel:function(px, inclusive) { return this.contains(px.x, px.y, inclusive); }, /** * APIMethod: contains * * Parameters: * x - {Float} * y - {Float} * inclusive - {Boolean} Whether or not to include the border. Default is * true. * * Returns: * {Boolean} Whether or not the passed-in coordinates are within this * bounds. */ contains:function(x, y, inclusive) { //set default if (inclusive == null) { inclusive = true; } var contains = false; if (inclusive) { contains = ((x >= this.left) && (x <= this.right) && (y >= this.bottom) && (y <= this.top)); } else { contains = ((x > this.left) && (x < this.right) && (y > this.bottom) && (y < this.top)); } return contains; }, /** * APIMethod: intersectsBounds * * Parameters: * bounds - {} * inclusive - {Boolean} Whether or not to include the border. Default * is true. * * Returns: * {Boolean} The passed-in OpenLayers.Bounds object intersects this bounds. * Simple math just check if either contains the other, allowing for * partial. */ intersectsBounds:function(bounds, inclusive) { if (inclusive == null) { inclusive = true; } var inBottom = (bounds.bottom == this.bottom && bounds.top == this.top) ? true : (((bounds.bottom > this.bottom) && (bounds.bottom < this.top)) || ((this.bottom > bounds.bottom) && (this.bottom < bounds.top))); var inTop = (bounds.bottom == this.bottom && bounds.top == this.top) ? true : (((bounds.top > this.bottom) && (bounds.top < this.top)) || ((this.top > bounds.bottom) && (this.top < bounds.top))); var inRight = (bounds.right == this.right && bounds.left == this.left) ? true : (((bounds.right > this.left) && (bounds.right < this.right)) || ((this.right > bounds.left) && (this.right < bounds.right))); var inLeft = (bounds.right == this.right && bounds.left == this.left) ? true : (((bounds.left > this.left) && (bounds.left < this.right)) || ((this.left > bounds.left) && (this.left < bounds.right))); return (this.containsBounds(bounds, true, inclusive) || bounds.containsBounds(this, true, inclusive) || ((inTop || inBottom ) && (inLeft || inRight ))); }, /** * APIMethod: containsBounds * * bounds - {} * partial - {Boolean} If true, only part of passed-in bounds needs be * within this bounds. If false, the entire passed-in bounds must be * within. Default is false * inclusive - {Boolean} Whether or not to include the border. Default is * true. * * Returns: * {Boolean} The passed-in bounds object is contained within this bounds. */ containsBounds:function(bounds, partial, inclusive) { //set defaults if (partial == null) { partial = false; } if (inclusive == null) { inclusive = true; } var inLeft; var inTop; var inRight; var inBottom; if (inclusive) { inLeft = (bounds.left >= this.left) && (bounds.left <= this.right); inTop = (bounds.top >= this.bottom) && (bounds.top <= this.top); inRight= (bounds.right >= this.left) && (bounds.right <= this.right); inBottom = (bounds.bottom >= this.bottom) && (bounds.bottom <= this.top); } else { inLeft = (bounds.left > this.left) && (bounds.left < this.right); inTop = (bounds.top > this.bottom) && (bounds.top < this.top); inRight= (bounds.right > this.left) && (bounds.right < this.right); inBottom = (bounds.bottom > this.bottom) && (bounds.bottom < this.top); } return (partial) ? (inTop || inBottom ) && (inLeft || inRight ) : (inTop && inLeft && inBottom && inRight); }, /** * APIMethod: determineQuadrant * * Parameters: * lonlat - {} * * Returns: * {String} The quadrant ("br" "tr" "tl" "bl") of the bounds in which the * coordinate lies. */ determineQuadrant: function(lonlat) { var quadrant = ""; var center = this.getCenterLonLat(); quadrant += (lonlat.lat < center.lat) ? "b" : "t"; quadrant += (lonlat.lon < center.lon) ? "l" : "r"; return quadrant; }, /** * APIMethod: transform * Transform the Bounds object from source to dest. * * Parameters: * source - {} Source projection. * dest - {} Destination projection. * * Returns: * {} Itself, for use in chaining operations. */ transform: function(source, dest) { var ll = OpenLayers.Projection.transform( {'x': this.left, 'y': this.bottom}, source, dest); var lr = OpenLayers.Projection.transform( {'x': this.right, 'y': this.bottom}, source, dest); var ul = OpenLayers.Projection.transform( {'x': this.left, 'y': this.top}, source, dest); var ur = OpenLayers.Projection.transform( {'x': this.right, 'y': this.top}, source, dest); this.left = Math.min(ll.x, ul.x); this.bottom = Math.min(ll.y, lr.y); this.right = Math.max(lr.x, ur.x); this.top = Math.max(ul.y, ur.y); return this; }, /** * APIMethod: wrapDateLine * * Parameters: * maxExtent - {} * options - {Object} Some possible options are: * leftTolerance - {float} Allow for a margin of error * with the 'left' value of this * bound. * Default is 0. * rightTolerance - {float} Allow for a margin of error * with the 'right' value of * this bound. * Default is 0. * * Returns: * {} A copy of this bounds, but wrapped around the * "dateline" (as specified by the borders of * maxExtent). Note that this function only returns * a different bounds value if this bounds is * *entirely* outside of the maxExtent. If this * bounds straddles the dateline (is part in/part * out of maxExtent), the returned bounds will be * merely a copy of this one. */ wrapDateLine: function(maxExtent, options) { options = options || {}; var leftTolerance = options.leftTolerance || 0; var rightTolerance = options.rightTolerance || 0; var newBounds = this.clone(); if (maxExtent) { //shift right? while ( newBounds.left < maxExtent.left && (newBounds.right - rightTolerance) <= maxExtent.left ) { newBounds = newBounds.add(maxExtent.getWidth(), 0); } //shift left? while ( (newBounds.left + leftTolerance) >= maxExtent.right && newBounds.right > maxExtent.right ) { newBounds = newBounds.add(-maxExtent.getWidth(), 0); } } return newBounds; }, CLASS_NAME: "OpenLayers.Bounds" }); /** * APIFunction: fromString * Alternative constructor that builds a new OpenLayers.Bounds from a * parameter string * * Parameters: * str - {String}Comma-separated bounds string. (ex. "5,42,10,45") * * Returns: * {} New bounds object built from the * passed-in String. */ OpenLayers.Bounds.fromString = function(str) { var bounds = str.split(","); return OpenLayers.Bounds.fromArray(bounds); }; /** * APIFunction: fromArray * Alternative constructor that builds a new OpenLayers.Bounds * from an array * * Parameters: * bbox - {Array(Float)} Array of bounds values (ex. [5,42,10,45]) * * Returns: * {} New bounds object built from the passed-in Array. */ OpenLayers.Bounds.fromArray = function(bbox) { return new OpenLayers.Bounds(parseFloat(bbox[0]), parseFloat(bbox[1]), parseFloat(bbox[2]), parseFloat(bbox[3])); }; /** * APIFunction: fromSize * Alternative constructor that builds a new OpenLayers.Bounds * from a size * * Parameters: * size - {} * * Returns: * {} New bounds object built from the passed-in size. */ OpenLayers.Bounds.fromSize = function(size) { return new OpenLayers.Bounds(0, size.h, size.w, 0); }; /** * Function: oppositeQuadrant * Get the opposite quadrant for a given quadrant string. * * Parameters: * quadrant - {String} two character quadrant shortstring * * Returns: * {String} The opposing quadrant ("br" "tr" "tl" "bl"). For Example, if * you pass in "bl" it returns "tr", if you pass in "br" it * returns "tl", etc. */ OpenLayers.Bounds.oppositeQuadrant = function(quadrant) { var opp = ""; opp += (quadrant.charAt(0) == 't') ? 'b' : 't'; opp += (quadrant.charAt(1) == 'l') ? 'r' : 'l'; return opp; }; /* ====================================================================== OpenLayers/BaseTypes/Element.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Namespace: OpenLayers.Element */ OpenLayers.Element = { /** * APIFunction: visible * * Parameters: * element - {DOMElement} * * Returns: * {Boolean} Is the element visible? */ visible: function(element) { return OpenLayers.Util.getElement(element).style.display != 'none'; }, /** * APIFunction: toggle * Toggle the visibility of element(s) passed in * * Parameters: * element - {DOMElement} Actually user can pass any number of elements */ toggle: function() { for (var i = 0; i < arguments.length; i++) { var element = OpenLayers.Util.getElement(arguments[i]); var display = OpenLayers.Element.visible(element) ? 'hide' : 'show'; OpenLayers.Element[display](element); } }, /** * APIFunction: hide * Hide element(s) passed in * * Parameters: * element - {DOMElement} Actually user can pass any number of elements */ hide: function() { for (var i = 0; i < arguments.length; i++) { var element = OpenLayers.Util.getElement(arguments[i]); element.style.display = 'none'; } }, /** * APIFunction: show * Show element(s) passed in * * Parameters: * element - {DOMElement} Actually user can pass any number of elements */ show: function() { for (var i = 0; i < arguments.length; i++) { var element = OpenLayers.Util.getElement(arguments[i]); element.style.display = ''; } }, /** * APIFunction: remove * Remove the specified element from the DOM. * * Parameters: * element - {DOMElement} */ remove: function(element) { element = OpenLayers.Util.getElement(element); element.parentNode.removeChild(element); }, /** * APIFunction: getHeight * * Parameters: * element - {DOMElement} * * Returns: * {Integer} The offset height of the element passed in */ getHeight: function(element) { element = OpenLayers.Util.getElement(element); return element.offsetHeight; }, /** * APIFunction: getDimensions * * Parameters: * element - {DOMElement} * * Returns: * {Object} Object with 'width' and 'height' properties which are the * dimensions of the element passed in. */ getDimensions: function(element) { element = OpenLayers.Util.getElement(element); if (OpenLayers.Element.getStyle(element, 'display') != 'none') { return {width: element.offsetWidth, height: element.offsetHeight}; } // All *Width and *Height properties give 0 on elements with display none, // so enable the element temporarily var els = element.style; var originalVisibility = els.visibility; var originalPosition = els.position; els.visibility = 'hidden'; els.position = 'absolute'; els.display = ''; var originalWidth = element.clientWidth; var originalHeight = element.clientHeight; els.display = 'none'; els.position = originalPosition; els.visibility = originalVisibility; return {width: originalWidth, height: originalHeight}; }, /** * APIFunction: getStyle * * Parameters: * element - {DOMElement} * style - {?} * * Returns: * {?} */ getStyle: function(element, style) { element = OpenLayers.Util.getElement(element); var value = element.style[OpenLayers.String.camelize(style)]; if (!value) { if (document.defaultView && document.defaultView.getComputedStyle) { var css = document.defaultView.getComputedStyle(element, null); value = css ? css.getPropertyValue(style) : null; } else if (element.currentStyle) { value = element.currentStyle[OpenLayers.String.camelize(style)]; } } var positions = ['left', 'top', 'right', 'bottom']; if (window.opera && (OpenLayers.Util.indexOf(positions,style) != -1) && (OpenLayers.Element.getStyle(element, 'position') == 'static')) { value = 'auto'; } return value == 'auto' ? null : value; } }; /* ====================================================================== OpenLayers/BaseTypes/LonLat.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Class: OpenLayers.LonLat * This class represents a longitude and latitude pair */ OpenLayers.LonLat = OpenLayers.Class({ /** * APIProperty: lon * {Float} The x-axis coodinate in map units */ lon: 0.0, /** * APIProperty: lat * {Float} The y-axis coordinate in map units */ lat: 0.0, /** * Constructor: OpenLayers.LonLat * Create a new map location. * * Parameters: * lon - {Number} The x-axis coordinate in map units. If your map is in * a geographic projection, this will be the Longitude. Otherwise, * it will be the x coordinate of the map location in your map units. * lat - {Number} The y-axis coordinate in map units. If your map is in * a geographic projection, this will be the Latitude. Otherwise, * it will be the y coordinate of the map location in your map units. */ initialize: function(lon, lat) { this.lon = parseFloat(lon); this.lat = parseFloat(lat); }, /** * Method: toString * Return a readable string version of the lonlat * * Returns: * {String} String representation of OpenLayers.LonLat object. * (ex. "lon=5,lat=42") */ toString:function() { return ("lon=" + this.lon + ",lat=" + this.lat); }, /** * APIMethod: toShortString * * Returns: * {String} Shortened String representation of OpenLayers.LonLat object. * (ex. "5, 42") */ toShortString:function() { return (this.lon + ", " + this.lat); }, /** * APIMethod: clone * * Returns: * {} New OpenLayers.LonLat object with the same lon * and lat values */ clone:function() { return new OpenLayers.LonLat(this.lon, this.lat); }, /** * APIMethod: add * * Parameters: * lon - {Float} * lat - {Float} * * Returns: * {} A new OpenLayers.LonLat object with the lon and * lat passed-in added to this's. */ add:function(lon, lat) { if ( (lon == null) || (lat == null) ) { var msg = OpenLayers.i18n("lonlatAddError"); OpenLayers.Console.error(msg); return null; } return new OpenLayers.LonLat(this.lon + lon, this.lat + lat); }, /** * APIMethod: equals * * Parameters: * ll - {} * * Returns: * {Boolean} Boolean value indicating whether the passed-in * object has the same lon and lat * components as this. * Note: if ll passed in is null, returns false */ equals:function(ll) { var equals = false; if (ll != null) { equals = ((this.lon == ll.lon && this.lat == ll.lat) || (isNaN(this.lon) && isNaN(this.lat) && isNaN(ll.lon) && isNaN(ll.lat))); } return equals; }, /** * APIMethod: transform * Transform the LonLat object from source to dest. * * Parameters: * source - {} Source projection. * dest - {} Destination projection. * * Returns: * {} Itself, for use in chaining operations. */ transform: function(source, dest) { var point = OpenLayers.Projection.transform( {'x': this.lon, 'y': this.lat}, source, dest); this.lon = point.x; this.lat = point.y; return this; }, /** * APIMethod: wrapDateLine * * Parameters: * maxExtent - {} * * Returns: * {} A copy of this lonlat, but wrapped around the * "dateline" (as specified by the borders of * maxExtent) */ wrapDateLine: function(maxExtent) { var newLonLat = this.clone(); if (maxExtent) { //shift right? while (newLonLat.lon < maxExtent.left) { newLonLat.lon += maxExtent.getWidth(); } //shift left? while (newLonLat.lon > maxExtent.right) { newLonLat.lon -= maxExtent.getWidth(); } } return newLonLat; }, CLASS_NAME: "OpenLayers.LonLat" }); /** * Function: fromString * Alternative constructor that builds a new from a * parameter string * * Parameters: * str - {String} Comma-separated Lon,Lat coordinate string. * (ex. "5,40") * * Returns: * {} New object built from the * passed-in String. */ OpenLayers.LonLat.fromString = function(str) { var pair = str.split(","); return new OpenLayers.LonLat(parseFloat(pair[0]), parseFloat(pair[1])); }; /* ====================================================================== OpenLayers/BaseTypes/Pixel.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Class: OpenLayers.Pixel * This class represents a screen coordinate, in x and y coordinates */ OpenLayers.Pixel = OpenLayers.Class({ /** * APIProperty: x * {Number} The x coordinate */ x: 0.0, /** * APIProperty: y * {Number} The y coordinate */ y: 0.0, /** * Constructor: OpenLayers.Pixel * Create a new OpenLayers.Pixel instance * * Parameters: * x - {Number} The x coordinate * y - {Number} The y coordinate * * Returns: * An instance of OpenLayers.Pixel */ initialize: function(x, y) { this.x = parseFloat(x); this.y = parseFloat(y); }, /** * Method: toString * Cast this object into a string * * Returns: * {String} The string representation of Pixel. ex: "x=200.4,y=242.2" */ toString:function() { return ("x=" + this.x + ",y=" + this.y); }, /** * APIMethod: clone * Return a clone of this pixel object * * Returns: * {} A clone pixel */ clone:function() { return new OpenLayers.Pixel(this.x, this.y); }, /** * APIMethod: equals * Determine whether one pixel is equivalent to another * * Parameters: * px - {} * * Returns: * {Boolean} The point passed in as parameter is equal to this. Note that * if px passed in is null, returns false. */ equals:function(px) { var equals = false; if (px != null) { equals = ((this.x == px.x && this.y == px.y) || (isNaN(this.x) && isNaN(this.y) && isNaN(px.x) && isNaN(px.y))); } return equals; }, /** * APIMethod: add * * Parameters: * x - {Integer} * y - {Integer} * * Returns: * {} A new Pixel with this pixel's x&y augmented by the * values passed in. */ add:function(x, y) { if ( (x == null) || (y == null) ) { var msg = OpenLayers.i18n("pixelAddError"); OpenLayers.Console.error(msg); return null; } return new OpenLayers.Pixel(this.x + x, this.y + y); }, /** * APIMethod: offset * * Parameters * px - {} * * Returns: * {} A new Pixel with this pixel's x&y augmented by the * x&y values of the pixel passed in. */ offset:function(px) { var newPx = this.clone(); if (px) { newPx = this.add(px.x, px.y); } return newPx; }, CLASS_NAME: "OpenLayers.Pixel" }); /* ====================================================================== OpenLayers/BaseTypes/Size.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Class: OpenLayers.Size * Instances of this class represent a width/height pair */ OpenLayers.Size = OpenLayers.Class({ /** * APIProperty: w * {Number} width */ w: 0.0, /** * APIProperty: h * {Number} height */ h: 0.0, /** * Constructor: OpenLayers.Size * Create an instance of OpenLayers.Size * * Parameters: * w - {Number} width * h - {Number} height */ initialize: function(w, h) { this.w = parseFloat(w); this.h = parseFloat(h); }, /** * Method: toString * Return the string representation of a size object * * Returns: * {String} The string representation of OpenLayers.Size object. * (ex. "w=55,h=66") */ toString:function() { return ("w=" + this.w + ",h=" + this.h); }, /** * APIMethod: clone * Create a clone of this size object * * Returns: * {} A new OpenLayers.Size object with the same w and h * values */ clone:function() { return new OpenLayers.Size(this.w, this.h); }, /** * * APIMethod: equals * Determine where this size is equal to another * * Parameters: * sz - {} * * Returns: * {Boolean} The passed in size has the same h and w properties as this one. * Note that if sz passed in is null, returns false. * */ equals:function(sz) { var equals = false; if (sz != null) { equals = ((this.w == sz.w && this.h == sz.h) || (isNaN(this.w) && isNaN(this.h) && isNaN(sz.w) && isNaN(sz.h))); } return equals; }, CLASS_NAME: "OpenLayers.Size" }); /* ====================================================================== OpenLayers/Console.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Namespace: OpenLayers.Console * The OpenLayers.Console namespace is used for debugging and error logging. * If the Firebug Lite (../Firebug/firebug.js) is included before this script, * calls to OpenLayers.Console methods will get redirected to window.console. * This makes use of the Firebug extension where available and allows for * cross-browser debugging Firebug style. * * Note: * Note that behavior will differ with the Firebug extention and Firebug Lite. * Most notably, the Firebug Lite console does not currently allow for * hyperlinks to code or for clicking on object to explore their properties. * */ OpenLayers.Console = { /** * Create empty functions for all console methods. The real value of these * properties will be set if Firebug Lite (../Firebug/firebug.js script) is * included. We explicitly require the Firebug Lite script to trigger * functionality of the OpenLayers.Console methods. */ /** * APIFunction: log * Log an object in the console. The Firebug Lite console logs string * representation of objects. Given multiple arguments, they will * be cast to strings and logged with a space delimiter. If the first * argument is a string with printf-like formatting, subsequent arguments * will be used in string substitution. Any additional arguments (beyond * the number substituted in a format string) will be appended in a space- * delimited line. * * Parameters: * object - {Object} */ log: function() {}, /** * APIFunction: debug * Writes a message to the console, including a hyperlink to the line * where it was called. * * May be called with multiple arguments as with OpenLayers.Console.log(). * * Parameters: * object - {Object} */ debug: function() {}, /** * APIFunction: info * Writes a message to the console with the visual "info" icon and color * coding and a hyperlink to the line where it was called. * * May be called with multiple arguments as with OpenLayers.Console.log(). * * Parameters: * object - {Object} */ info: function() {}, /** * APIFunction: warn * Writes a message to the console with the visual "warning" icon and * color coding and a hyperlink to the line where it was called. * * May be called with multiple arguments as with OpenLayers.Console.log(). * * Parameters: * object - {Object} */ warn: function() {}, /** * APIFunction: error * Writes a message to the console with the visual "error" icon and color * coding and a hyperlink to the line where it was called. * * May be called with multiple arguments as with OpenLayers.Console.log(). * * Parameters: * object - {Object} */ error: function() {}, /** * APIFunction: assert * Tests that an expression is true. If not, it will write a message to * the console and throw an exception. * * May be called with multiple arguments as with OpenLayers.Console.log(). * * Parameters: * object - {Object} */ assert: function() {}, /** * APIFunction: dir * Prints an interactive listing of all properties of the object. This * looks identical to the view that you would see in the DOM tab. * * Parameters: * object - {Object} */ dir: function() {}, /** * APIFunction: dirxml * Prints the XML source tree of an HTML or XML element. This looks * identical to the view that you would see in the HTML tab. You can click * on any node to inspect it in the HTML tab. * * Parameters: * object - {Object} */ dirxml: function() {}, /** * APIFunction: trace * Prints an interactive stack trace of JavaScript execution at the point * where it is called. The stack trace details the functions on the stack, * as well as the values that were passed as arguments to each function. * You can click each function to take you to its source in the Script tab, * and click each argument value to inspect it in the DOM or HTML tabs. * */ trace: function() {}, /** * APIFunction: group * Writes a message to the console and opens a nested block to indent all * future messages sent to the console. Call OpenLayers.Console.groupEnd() * to close the block. * * May be called with multiple arguments as with OpenLayers.Console.log(). * * Parameters: * object - {Object} */ group: function() {}, /** * APIFunction: groupEnd * Closes the most recently opened block created by a call to * OpenLayers.Console.group */ groupEnd: function() {}, /** * APIFunction: time * Creates a new timer under the given name. Call * OpenLayers.Console.timeEnd(name) * with the same name to stop the timer and print the time elapsed. * * Parameters: * name - {String} */ time: function() {}, /** * APIFunction: timeEnd * Stops a timer created by a call to OpenLayers.Console.time(name) and * writes the time elapsed. * * Parameters: * name - {String} */ timeEnd: function() {}, /** * APIFunction: profile * Turns on the JavaScript profiler. The optional argument title would * contain the text to be printed in the header of the profile report. * * This function is not currently implemented in Firebug Lite. * * Parameters: * title - {String} Optional title for the profiler */ profile: function() {}, /** * APIFunction: profileEnd * Turns off the JavaScript profiler and prints its report. * * This function is not currently implemented in Firebug Lite. */ profileEnd: function() {}, /** * APIFunction: count * Writes the number of times that the line of code where count was called * was executed. The optional argument title will print a message in * addition to the number of the count. * * This function is not currently implemented in Firebug Lite. * * Parameters: * title - {String} Optional title to be printed with count */ count: function() {}, CLASS_NAME: "OpenLayers.Console" }; /** * Execute an anonymous function to extend the OpenLayers.Console namespace * if the firebug.js script is included. This closure is used so that the * "scripts" and "i" variables don't pollute the global namespace. */ (function() { /** * If Firebug Lite is included (before this script), re-route all * OpenLayers.Console calls to the console object. */ if(window.console) { var scripts = document.getElementsByTagName("script"); for(var i=0; i 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) { * > alert(bounds); * > } * > }); * > map.addControl(control); * */ OpenLayers.Control = OpenLayers.Class({ /** * Property: id * {String} */ id: null, /** * Property: map * {} this gets set in the addControl() function in * OpenLayers.Map */ map: null, /** * Property: div * {DOMElement} */ div: null, /** * Property: type * {OpenLayers.Control.TYPES} Controls can have a 'type'. The type * determines the type of interactions which are possible with them when * they are placed into a toolbar. */ 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: "", /** * Property: title * {string} This property is used for showing a tooltip over the * Control. */ title: "", /** * Property: active * {Boolean} The control is active. */ active: null, /** * Property: handler * {} null */ handler: null, /** * APIProperty: eventListeners * {Object} If set as an option at construction, the eventListeners * object will be registered with . Object * structure must be a listeners object as shown in the example for * the events.on method. */ eventListeners: null, /** * Property: events * {} Events instance for 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); } 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; } }, /** * 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 - {} */ 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 - {} 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 = function() { return(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 - {} */ moveTo: function (px) { if ((px != null) && (this.div != null)) { this.div.style.left = px.x + "px"; this.div.style.top = px.y + "px"; } }, /** * Method: 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; this.events.triggerEvent("activate"); return true; }, /** * Method: 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; this.events.triggerEvent("deactivate"); return true; } return false; }, CLASS_NAME: "OpenLayers.Control" }); OpenLayers.Control.TYPE_BUTTON = 1; OpenLayers.Control.TYPE_TOGGLE = 2; OpenLayers.Control.TYPE_TOOL = 3; /* ====================================================================== OpenLayers/Icon.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Class: OpenLayers.Icon * * The icon represents a graphical icon on the screen. Typically used in * conjunction with a to represent markers on a screen. * * An icon has a url, size and position. It also contains an offset which * allows the center point to be represented correctly. This can be * provided either as a fixed offset or a function provided to calculate * the desired offset. * */ OpenLayers.Icon = OpenLayers.Class({ /** * Property: url * {String} image url */ url: null, /** * Property: size * {} */ size: null, /** * Property: offset * {} distance in pixels to offset the image when being rendered */ offset: null, /** * Property: calculateOffset * {} Function to calculate the offset (based on the size) */ calculateOffset: null, /** * Property: imageDiv * {DOMElement} */ imageDiv: null, /** * Property: px * {} */ px: null, /** * Constructor: OpenLayers.Icon * Creates an icon, which is an image tag in a div. * * url - {String} * size - {} * offset - {} * calculateOffset - {Function} */ initialize: function(url, size, offset, calculateOffset) { this.url = url; this.size = (size) ? size : new OpenLayers.Size(20,20); this.offset = offset ? offset : new OpenLayers.Pixel(-(this.size.w/2), -(this.size.h/2)); this.calculateOffset = calculateOffset; var id = OpenLayers.Util.createUniqueID("OL_Icon_"); this.imageDiv = OpenLayers.Util.createAlphaImageDiv(id); }, /** * Method: destroy * Nullify references and remove event listeners to prevent circular * references and memory leaks */ destroy: function() { OpenLayers.Event.stopObservingElement(this.imageDiv.firstChild); this.imageDiv.innerHTML = ""; this.imageDiv = null; }, /** * Method: clone * * Returns: * {} A fresh copy of the icon. */ clone: function() { return new OpenLayers.Icon(this.url, this.size, this.offset, this.calculateOffset); }, /** * Method: setSize * * Parameters: * size - {} */ setSize: function(size) { if (size != null) { this.size = size; } this.draw(); }, /** * Method: setUrl * * Parameters: * url - {String} */ setUrl: function(url) { if (url != null) { this.url = url; } this.draw(); }, /** * Method: draw * Move the div to the given pixel. * * Parameters: * px - {} * * Returns: * {DOMElement} A new DOM Image of this icon set at the location passed-in */ draw: function(px) { OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, null, this.size, this.url, "absolute"); this.moveTo(px); return this.imageDiv; }, /** * Method: setOpacity * Change the icon's opacity * * Parameters: * opacity - {float} */ setOpacity: function(opacity) { OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, null, null, null, null, null, null, opacity); }, /** * Method: moveTo * move icon to passed in px. * * Parameters: * px - {} */ moveTo: function (px) { //if no px passed in, use stored location if (px != null) { this.px = px; } if (this.imageDiv != null) { if (this.px == null) { this.display(false); } else { if (this.calculateOffset) { this.offset = this.calculateOffset(this.size); } var offsetPx = this.px.offset(this.offset); OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, offsetPx); } } }, /** * Method: display * Hide or show the icon * * Parameters: * display - {Boolean} */ display: function(display) { this.imageDiv.style.display = (display) ? "" : "none"; }, CLASS_NAME: "OpenLayers.Icon" }); /* ====================================================================== OpenLayers/Lang.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Namespace: OpenLayers.Lang * Internationalization namespace. Contains dictionaries in various languages * and methods to set and get the current language. */ OpenLayers.Lang = { /** * Property: code * {String} Current language code to use in OpenLayers. Use the * method to set this value and the method to * retrieve it. */ code: null, /** * APIProperty: defaultCode * {String} Default language to use when a specific language can't be * found. Default is "en". */ defaultCode: "en", /** * APIFunction: getCode * Get the current language code. * * Returns: * The current language code. */ getCode: function() { if(!OpenLayers.Lang.code) { OpenLayers.Lang.setCode(); } return OpenLayers.Lang.code; }, /** * APIFunction: setCode * Set the language code for string translation. This code is used by * the method. * * Parameters- * code - {String} These codes follow the IETF recommendations at * http://www.ietf.org/rfc/rfc3066.txt. If no value is set, the * browser's language setting will be tested. If no * dictionary exists for the code, the * will be used. */ setCode: function(code) { var lang; if(!code) { code = (OpenLayers.Util.getBrowserName() == "msie") ? navigator.userLanguage : navigator.language; } var parts = code.split('-'); parts[0] = parts[0].toLowerCase(); if(typeof OpenLayers.Lang[parts[0]] == "object") { lang = parts[0]; } // check for regional extensions if(parts[1]) { var testLang = parts[0] + '-' + parts[1].toUpperCase(); if(typeof OpenLayers.Lang[testLang] == "object") { lang = testLang; } } if(!lang) { OpenLayers.Console.warn( 'Failed to find OpenLayers.Lang.' + parts.join("-") + ' dictionary, falling back to default language' ); lang = OpenLayers.Lang.defaultCode; } OpenLayers.Lang.code = lang; }, /** * APIMethod: translate * Looks up a key from a dictionary based on the current language string. * The value of will be used to determine the appropriate * dictionary. Dictionaries are stored in . * * Parameters: * key - {String} The key for an i18n string value in the dictionary. * context - {Object} Optional context to be used with * . * * Returns: * {String} A internationalized string. */ translate: function(key, context) { var dictionary = OpenLayers.Lang[OpenLayers.Lang.getCode()]; var message = dictionary[key]; if(!message) { // Message not found, fall back to message key message = key; } if(context) { message = OpenLayers.String.format(message, context); } return message; } }; /** * APIMethod: OpenLayers.i18n * Alias for . Looks up a key from a dictionary * based on the current language string. The value of * will be used to determine the appropriate * dictionary. Dictionaries are stored in . * * Parameters: * key - {String} The key for an i18n string value in the dictionary. * context - {Object} Optional context to be used with * . * * Returns: * {String} A internationalized string. */ OpenLayers.i18n = OpenLayers.Lang.translate; /* ====================================================================== OpenLayers/Popup.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Class: OpenLayers.Popup * A popup is a small div that can opened and closed on the map. * Typically opened in response to clicking on a marker. * See . Popup's don't require their own * layer and are added the the map using the * method. * * Example: * (code) * popup = new OpenLayers.Popup("chicken", * new OpenLayers.LonLat(5,40), * new OpenLayers.Size(200,200), * "example popup", * true); * * map.addPopup(popup); * (end) */ OpenLayers.Popup = OpenLayers.Class({ /** * Property: events * {} custom event manager */ events: null, /** Property: id * {String} the unique identifier assigned to this popup. */ id: "", /** * Property: lonlat * {} the position of this popup on the map */ lonlat: null, /** * Property: div * {DOMElement} the div that contains this popup. */ div: null, /** * Property: size * {} the width and height of the popup. */ size: null, /** * Property: contentHTML * {String} The HTML that this popup displays. */ contentHTML: "", /** * Property: backgroundColor * {String} the background color used by the popup. */ backgroundColor: "", /** * Property: opacity * {float} the opacity of this popup (between 0.0 and 1.0) */ opacity: "", /** * Property: border * {String} the border size of the popup. (eg 2px) */ border: "", /** * Property: contentDiv * {DOMElement} a reference to the element that holds the content of * the div. */ contentDiv: null, /** * Property: groupDiv * {DOMElement} First and only child of 'div'. The group Div contains the * 'contentDiv' and the 'closeDiv'. */ groupDiv: null, /** * Property: closeDiv * {DOMElement} the optional closer image */ closeDiv: null, /** * APIProperty: autoSize * {Boolean} Resize the popup to auto-fit the contents. * Default is false. */ autoSize: false, /** * APIProperty: minSize * {} Minimum size allowed for the popup's contents. */ minSize: null, /** * APIProperty: maxSize * {} Maximum size allowed for the popup's contents. */ maxSize: null, /** * Property: padding * {int or } An extra opportunity to specify internal * padding of the content div inside the popup. This was originally * confused with the css padding as specified in style.css's * 'olPopupContent' class. We would like to get rid of this altogether, * except that it does come in handy for the framed and anchoredbubble * popups, who need to maintain yet another barrier between their * content and the outer border of the popup itself. * * Note that in order to not break API, we must continue to support * this property being set as an integer. Really, though, we'd like to * have this specified as a Bounds object so that user can specify * distinct left, top, right, bottom paddings. With the 3.0 release * we can make this only a bounds. */ padding: 0, /** * Method: fixPadding * To be removed in 3.0, this function merely helps us to deal with the * case where the user may have set an integer value for padding, * instead of an object. */ fixPadding: function() { if (typeof this.padding == "number") { this.padding = new OpenLayers.Bounds( this.padding, this.padding, this.padding, this.padding ); } }, /** * APIProperty: panMapIfOutOfView * {Boolean} When drawn, pan map such that the entire popup is visible in * the current viewport (if necessary). * Default is false. */ panMapIfOutOfView: false, /** * Property: map * {} this gets set in Map.js when the popup is added to the map */ map: null, /** * Constructor: OpenLayers.Popup * Create a popup. * * Parameters: * id - {String} a unqiue identifier for this popup. If null is passed * an identifier will be automatically generated. * lonlat - {} The position on the map the popup will * be shown. * size - {} The size of the popup. * contentHTML - {String} The HTML content to display inside the * popup. * closeBox - {Boolean} Whether to display a close box inside * the popup. * closeBoxCallback - {Function} Function to be called on closeBox click. */ initialize:function(id, lonlat, size, contentHTML, closeBox, closeBoxCallback) { if (id == null) { id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); } this.id = id; this.lonlat = lonlat; this.size = (size != null) ? size : new OpenLayers.Size( OpenLayers.Popup.WIDTH, OpenLayers.Popup.HEIGHT); if (contentHTML != null) { this.contentHTML = contentHTML; } this.backgroundColor = OpenLayers.Popup.COLOR; this.opacity = OpenLayers.Popup.OPACITY; this.border = OpenLayers.Popup.BORDER; this.div = OpenLayers.Util.createDiv(this.id, null, null, null, null, null, "hidden"); this.div.className = 'olPopup'; var groupDivId = this.id + "_GroupDiv"; this.groupDiv = OpenLayers.Util.createDiv(groupDivId, null, null, null, "relative", null, "hidden"); var id = this.div.id + "_contentDiv"; this.contentDiv = OpenLayers.Util.createDiv(id, null, this.size.clone(), null, "relative"); this.contentDiv.className = 'olPopupContent'; this.groupDiv.appendChild(this.contentDiv); this.div.appendChild(this.groupDiv); if (closeBox) { this.addCloseBox(closeBoxCallback); } this.registerEvents(); }, /** * Method: destroy * nullify references to prevent circular references and memory leaks */ destroy: function() { this.id = null; this.lonlat = null; this.size = null; this.contentHTML = null; this.backgroundColor = null; this.opacity = null; this.border = null; this.events.destroy(); this.events = null; if (this.closeDiv) { OpenLayers.Event.stopObservingElement(this.closeDiv); this.groupDiv.removeChild(this.closeDiv); } this.closeDiv = null; this.div.removeChild(this.groupDiv); this.groupDiv = null; if (this.map != null) { this.map.removePopup(this); } this.map = null; this.div = null; this.autoSize = null; this.minSize = null; this.maxSize = null; this.padding = null; this.panMapIfOutOfView = null; }, /** * Method: draw * Constructs the elements that make up the popup. * * Parameters: * px - {} the position the popup in pixels. * * Returns: * {DOMElement} Reference to a div that contains the drawn popup */ draw: function(px) { if (px == null) { if ((this.lonlat != null) && (this.map != null)) { px = this.map.getLayerPxFromLonLat(this.lonlat); } } //listen to movestart, moveend to disable overflow (FF bug) if (OpenLayers.Util.getBrowserName() == 'firefox') { this.map.events.register("movestart", this, function() { var style = document.defaultView.getComputedStyle( this.contentDiv, null ); var currentOverflow = style.getPropertyValue("overflow"); if (currentOverflow != "hidden") { this.contentDiv._oldOverflow = currentOverflow; this.contentDiv.style.overflow = "hidden"; } }); this.map.events.register("moveend", this, function() { var oldOverflow = this.contentDiv._oldOverflow; if (oldOverflow) { this.contentDiv.style.overflow = oldOverflow; this.contentDiv._oldOverflow = null; } }); } this.moveTo(px); if (!this.autoSize) { this.setSize(this.size); } this.setBackgroundColor(); this.setOpacity(); this.setBorder(); this.setContentHTML(); if (this.panMapIfOutOfView) { this.panIntoView(); } return this.div; }, /** * Method: updatePosition * if the popup has a lonlat and its map members set, * then have it move itself to its proper position */ updatePosition: function() { if ((this.lonlat) && (this.map)) { var px = this.map.getLayerPxFromLonLat(this.lonlat); if (px) { this.moveTo(px); } } }, /** * Method: moveTo * * Parameters: * px - {} the top and left position of the popup div. */ moveTo: function(px) { if ((px != null) && (this.div != null)) { this.div.style.left = px.x + "px"; this.div.style.top = px.y + "px"; } }, /** * Method: visible * * Returns: * {Boolean} Boolean indicating whether or not the popup is visible */ visible: function() { return OpenLayers.Element.visible(this.div); }, /** * Method: toggle * Toggles visibility of the popup. */ toggle: function() { if (this.visible()) { this.hide(); } else { this.show(); } }, /** * Method: show * Makes the popup visible. */ show: function() { OpenLayers.Element.show(this.div); if (this.panMapIfOutOfView) { this.panIntoView(); } }, /** * Method: hide * Makes the popup invisible. */ hide: function() { OpenLayers.Element.hide(this.div); }, /** * Method: setSize * Used to adjust the size of the popup. * * Parameters: * size - {} the new size of the popup's contents div * (in pixels). */ setSize:function(size) { this.size = size; var contentSize = this.size.clone(); // if our contentDiv has a css 'padding' set on it by a stylesheet, we // must add that to the desired "size". var contentDivPadding = this.getContentDivPadding(); var wPadding = contentDivPadding.left + contentDivPadding.right; var hPadding = contentDivPadding.top + contentDivPadding.bottom; // take into account the popup's 'padding' property this.fixPadding(); wPadding += this.padding.left + this.padding.right; hPadding += this.padding.top + this.padding.bottom; // make extra space for the close div if (this.closeDiv) { var closeDivWidth = parseInt(this.closeDiv.style.width); wPadding += closeDivWidth + contentDivPadding.right; } //increase size of the main popup div to take into account the // users's desired padding and close div. this.size.w += wPadding; this.size.h += hPadding; //now if our browser is IE, we need to actually make the contents // div itself bigger to take its own padding into effect. this makes // me want to shoot someone, but so it goes. if (OpenLayers.Util.getBrowserName() == "msie") { contentSize.w += contentDivPadding.left + contentDivPadding.right; contentSize.h += contentDivPadding.bottom + contentDivPadding.top; } if (this.div != null) { this.div.style.width = this.size.w + "px"; this.div.style.height = this.size.h + "px"; } if (this.contentDiv != null){ this.contentDiv.style.width = contentSize.w + "px"; this.contentDiv.style.height = contentSize.h + "px"; } }, /** * Method: setBackgroundColor * Sets the background color of the popup. * * Parameters: * color - {String} the background color. eg "#FFBBBB" */ setBackgroundColor:function(color) { if (color != undefined) { this.backgroundColor = color; } if (this.div != null) { this.div.style.backgroundColor = this.backgroundColor; } }, /** * Method: setOpacity * Sets the opacity of the popup. * * Parameters: * opacity - {float} A value between 0.0 (transparent) and 1.0 (solid). */ setOpacity:function(opacity) { if (opacity != undefined) { this.opacity = opacity; } if (this.div != null) { // for Mozilla and Safari this.div.style.opacity = this.opacity; // for IE this.div.style.filter = 'alpha(opacity=' + this.opacity*100 + ')'; } }, /** * Method: setBorder * Sets the border style of the popup. * * Parameters: * border - {String} The border style value. eg 2px */ setBorder:function(border) { if (border != undefined) { this.border = border; } if (this.div != null) { this.div.style.border = this.border; } }, /** * Method: setContentHTML * Allows the user to set the HTML content of the popup. * * Parameters: * contentHTML - {String} HTML for the div. */ setContentHTML:function(contentHTML) { if (contentHTML != null) { this.contentHTML = contentHTML; } if (this.autoSize) { // determine actual render dimensions of the contents var realSize = OpenLayers.Util.getRenderedDimensions(this.contentHTML); // is the "real" size of the div is safe to display in our map? var safeSize = this.getSafeContentSize(realSize); var newSize = null; if (safeSize.equals(realSize)) { //real size of content is small enough to fit on the map, // so we use real size. newSize = realSize; } else { //make a new OL.Size object with the clipped dimensions // set or null if not clipped. var fixedSize = new OpenLayers.Size(); fixedSize.w = (safeSize.w < realSize.w) ? safeSize.w : null; fixedSize.h = (safeSize.h < realSize.h) ? safeSize.h : null; if (fixedSize.w && fixedSize.h) { //content is too big in both directions, so we will use // max popup size (safeSize), knowing well that it will // overflow both ways. newSize = safeSize; } else { //content is clipped in only one direction, so we need to // run getRenderedDimensions() again with a fixed dimension var clippedSize = OpenLayers.Util.getRenderedDimensions( this.contentHTML, fixedSize ); //if the clipped size is still the same as the safeSize, // that means that our content must be fixed in the // offending direction. If overflow is 'auto', this means // we are going to have a scrollbar for sure, so we must // adjust for that. // var currentOverflow = OpenLayers.Element.getStyle( this.contentDiv, "overflow" ); if ( (currentOverflow != "hidden") && (clippedSize.equals(safeSize)) ) { var scrollBar = OpenLayers.Util.getScrollbarWidth(); if (fixedSize.w) { clippedSize.h += scrollBar; } else { clippedSize.w += scrollBar; } } newSize = this.getSafeContentSize(clippedSize); } } this.setSize(newSize); } if (this.contentDiv != null) { this.contentDiv.innerHTML = this.contentHTML; } }, /** * APIMethod: getSafeContentSize * * Parameters: * size - {} Desired size to make the popup. * * Returns: * {} A size to make the popup which is neither smaller * than the specified minimum size, nor bigger than the maximum * size (which is calculated relative to the size of the viewport). */ getSafeContentSize: function(size) { var safeContentSize = size.clone(); // if our contentDiv has a css 'padding' set on it by a stylesheet, we // must add that to the desired "size". var contentDivPadding = this.getContentDivPadding(); var wPadding = contentDivPadding.left + contentDivPadding.right; var hPadding = contentDivPadding.top + contentDivPadding.bottom; // take into account the popup's 'padding' property this.fixPadding(); wPadding += this.padding.left + this.padding.right; hPadding += this.padding.top + this.padding.bottom; if (this.closeDiv) { var closeDivWidth = parseInt(this.closeDiv.style.width); wPadding += closeDivWidth + contentDivPadding.right; } // prevent the popup from being smaller than a specified minimal size if (this.minSize) { safeContentSize.w = Math.max(safeContentSize.w, (this.minSize.w - wPadding)); safeContentSize.h = Math.max(safeContentSize.h, (this.minSize.h - hPadding)); } // prevent the popup from being bigger than a specified maximum size if (this.maxSize) { safeContentSize.w = Math.min(safeContentSize.w, (this.maxSize.w - wPadding)); safeContentSize.h = Math.min(safeContentSize.h, (this.maxSize.h - hPadding)); } //make sure the desired size to set doesn't result in a popup that // is bigger than the map's viewport. // if (this.map && this.map.size) { // Note that there *was* a reference to a // 'OpenLayers.Popup.SCROLL_BAR_WIDTH' constant here, with special // tolerance for it and everything... but it was never defined in // the first place, so I don't know what to think. var maxY = this.map.size.h - this.map.paddingForPopups.top - this.map.paddingForPopups.bottom - hPadding; var maxX = this.map.size.w - this.map.paddingForPopups.left - this.map.paddingForPopups.right - wPadding; safeContentSize.w = Math.min(safeContentSize.w, maxX); safeContentSize.h = Math.min(safeContentSize.h, maxY); } return safeContentSize; }, /** * Method: getContentDivPadding * Glorious, oh glorious hack in order to determine the css 'padding' of * the contentDiv. IE/Opera return null here unless we actually add the * popup's main 'div' element (which contains contentDiv) to the DOM. * So we make it invisible and then add it to the document temporarily. * * Once we've taken the padding readings we need, we then remove it * from the DOM (it will actually get added to the DOM in * Map.js's addPopup) * * Returns: * {} */ getContentDivPadding: function() { //use cached value if we have it var contentDivPadding = this._contentDivPadding; if (!contentDivPadding) { //make the div invisible and add it to the page this.div.style.display = "none"; document.body.appendChild(this.div); //read the padding settings from css, put them in an OL.Bounds contentDivPadding = new OpenLayers.Bounds( OpenLayers.Element.getStyle(this.contentDiv, "padding-left"), OpenLayers.Element.getStyle(this.contentDiv, "padding-bottom"), OpenLayers.Element.getStyle(this.contentDiv, "padding-right"), OpenLayers.Element.getStyle(this.contentDiv, "padding-top") ); //cache the value this._contentDivPadding = contentDivPadding; //remove the div from the page and make it visible again document.body.removeChild(this.div); this.div.style.display = ""; } return contentDivPadding; }, /** * Method: addCloseBox * * Parameters: * callback - {Function} The callback to be called when the close button * is clicked. */ addCloseBox: function(callback) { this.closeDiv = OpenLayers.Util.createDiv( this.id + "_close", null, new OpenLayers.Size(17, 17) ); this.closeDiv.className = "olPopupCloseBox"; // use the content div's css padding to determine if we should // padd the close div var contentDivPadding = this.getContentDivPadding(); this.closeDiv.style.right = contentDivPadding.right + "px"; this.closeDiv.style.top = contentDivPadding.top + "px"; this.groupDiv.appendChild(this.closeDiv); var closePopup = callback || function(e) { this.hide(); OpenLayers.Event.stop(e); }; OpenLayers.Event.observe(this.closeDiv, "click", OpenLayers.Function.bindAsEventListener(closePopup, this)); }, /** * Method: panIntoView * Pans the map such that the popup is totaly viewable (if necessary) */ panIntoView: function() { var mapSize = this.map.getSize(); //start with the top left corner of the popup, in px, // relative to the viewport var origTL = this.map.getViewPortPxFromLayerPx( new OpenLayers.Pixel( parseInt(this.div.style.left), parseInt(this.div.style.top) )); var newTL = origTL.clone(); //new left (compare to margins, using this.size to calculate right) if (origTL.x < this.map.paddingForPopups.left) { newTL.x = this.map.paddingForPopups.left; } else if ( (origTL.x + this.size.w) > (mapSize.w - this.map.paddingForPopups.right)) { newTL.x = mapSize.w - this.map.paddingForPopups.right - this.size.w; } //new top (compare to margins, using this.size to calculate bottom) if (origTL.y < this.map.paddingForPopups.top) { newTL.y = this.map.paddingForPopups.top; } else if ( (origTL.y + this.size.h) > (mapSize.h - this.map.paddingForPopups.bottom)) { newTL.y = mapSize.h - this.map.paddingForPopups.bottom - this.size.h; } var dx = origTL.x - newTL.x; var dy = origTL.y - newTL.y; this.map.pan(dx, dy); }, /** * Method: registerEvents * Registers events on the popup. * * Do this in a separate function so that subclasses can * choose to override it if they wish to deal differently * with mouse events * * Note in the following handler functions that some special * care is needed to deal correctly with mousing and popups. * * Because the user might select the zoom-rectangle option and * then drag it over a popup, we need a safe way to allow the * mousemove and mouseup events to pass through the popup when * they are initiated from outside. * * Otherwise, we want to essentially kill the event propagation * for all other events, though we have to do so carefully, * without disabling basic html functionality, like clicking on * hyperlinks or drag-selecting text. */ registerEvents:function() { this.events = new OpenLayers.Events(this, this.div, null, true); this.events.on({ "mousedown": this.onmousedown, "mousemove": this.onmousemove, "mouseup": this.onmouseup, "click": this.onclick, "mouseout": this.onmouseout, "dblclick": this.ondblclick, scope: this }); }, /** * Method: onmousedown * When mouse goes down within the popup, make a note of * it locally, and then do not propagate the mousedown * (but do so safely so that user can select text inside) * * Parameters: * evt - {Event} */ onmousedown: function (evt) { this.mousedown = true; OpenLayers.Event.stop(evt, true); }, /** * Method: onmousemove * If the drag was started within the popup, then * do not propagate the mousemove (but do so safely * so that user can select text inside) * * Parameters: * evt - {Event} */ onmousemove: function (evt) { if (this.mousedown) { OpenLayers.Event.stop(evt, true); } }, /** * Method: onmouseup * When mouse comes up within the popup, after going down * in it, reset the flag, and then (once again) do not * propagate the event, but do so safely so that user can * select text inside * * Parameters: * evt - {Event} */ onmouseup: function (evt) { if (this.mousedown) { this.mousedown = false; OpenLayers.Event.stop(evt, true); } }, /** * Method: onclick * Ignore clicks, but allowing default browser handling * * Parameters: * evt - {Event} */ onclick: function (evt) { OpenLayers.Event.stop(evt, true); }, /** * Method: onmouseout * When mouse goes out of the popup set the flag to false so that * if they let go and then drag back in, we won't be confused. * * Parameters: * evt - {Event} */ onmouseout: function (evt) { this.mousedown = false; }, /** * Method: ondblclick * Ignore double-clicks, but allowing default browser handling * * Parameters: * evt - {Event} */ ondblclick: function (evt) { OpenLayers.Event.stop(evt, true); }, CLASS_NAME: "OpenLayers.Popup" }); OpenLayers.Popup.WIDTH = 200; OpenLayers.Popup.HEIGHT = 200; OpenLayers.Popup.COLOR = "white"; OpenLayers.Popup.OPACITY = 1; OpenLayers.Popup.BORDER = "0px"; /* ====================================================================== OpenLayers/Renderer.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Class: OpenLayers.Renderer * This is the base class for all renderers. * * This is based on a merger code written by Paul Spencer and Bertil Chapuis. * It is largely composed of virtual functions that are to be implemented * in technology-specific subclasses, but there is some generic code too. * * The functions that *are* implemented here merely deal with the maintenance * of the size and extent variables, as well as the cached 'resolution' * value. * * A note to the user that all subclasses should use getResolution() instead * of directly accessing this.resolution in order to correctly use the * cacheing system. * */ OpenLayers.Renderer = OpenLayers.Class({ /** * Property: container * {DOMElement} */ container: null, /** * Property: extent * {} */ extent: null, /** * Property: size * {} */ size: null, /** * Property: resolution * {Float} cache of current map resolution */ resolution: null, /** * Property: map * {} Reference to the map -- this is set in Vector's setMap() */ map: null, /** * Constructor: OpenLayers.Renderer * * Parameters: * containerID - {} */ initialize: function(containerID) { this.container = OpenLayers.Util.getElement(containerID); }, /** * APIMethod: destroy */ destroy: function() { this.container = null; this.extent = null; this.size = null; this.resolution = null; this.map = null; }, /** * APIMethod: supported * This should be overridden by specific subclasses * * Returns: * {Boolean} Whether or not the browser supports the renderer class */ supported: function() { return false; }, /** * Method: setExtent * Set the visible part of the layer. * * Resolution has probably changed, so we nullify the resolution * cache (this.resolution) -- this way it will be re-computed when * next it is needed. * * Parameters: * extent - {} */ setExtent: function(extent) { this.extent = extent.clone(); this.resolution = null; }, /** * Method: setSize * Sets the size of the drawing surface. * * Resolution has probably changed, so we nullify the resolution * cache (this.resolution) -- this way it will be re-computed when * next it is needed. * * Parameters: * size - {} */ setSize: function(size) { this.size = size.clone(); this.resolution = null; }, /** * Method: getResolution * Uses cached copy of resolution if available to minimize computing * * Returns: * The current map's resolution */ getResolution: function() { this.resolution = this.resolution || this.map.getResolution(); return this.resolution; }, /** * Method: drawFeature * Draw the feature. The optional style argument can be used * to override the feature's own style. This method should only * be called from layer.drawFeature(). * * Parameters: * feature - {} * style - {} */ drawFeature: function(feature, style) { if(style == null) { style = feature.style; } if (feature.geometry) { this.drawGeometry(feature.geometry, style, feature.id); } }, /** * Method: drawGeometry * * Draw a geometry. This should only be called from the renderer itself. * Use layer.drawFeature() from outside the renderer. * virtual function * * Parameters: * geometry - {} * style - {Object} * featureId - {} */ drawGeometry: function(geometry, style, featureId) {}, /** * Method: clear * Clear all vectors from the renderer. * virtual function. */ clear: function() {}, /** * Method: getFeatureIdFromEvent * Returns a feature id from an event on the renderer. * How this happens is specific to the renderer. This should be * called from layer.getFeatureFromEvent(). * Virtual function. * * Parameters: * evt - {} * * Returns: * {String} A feature id or null. */ getFeatureIdFromEvent: function(evt) {}, /** * Method: eraseFeatures * This is called by the layer to erase features * * Parameters: * features - {Array()} */ eraseFeatures: function(features) { if(!(features instanceof Array)) { features = [features]; } for(var i=0; i} */ eraseGeometry: function(geometry) {}, CLASS_NAME: "OpenLayers.Renderer" }); /* ====================================================================== OpenLayers/Tween.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Namespace: OpenLayers.Tween */ OpenLayers.Tween = OpenLayers.Class({ /** * Constant: INTERVAL * {int} Interval in milliseconds between 2 steps */ INTERVAL: 10, /** * APIProperty: easing * {(Function)} Easing equation used for the animation * Defaultly set to OpenLayers.Easing.Expo.easeOut */ easing: null, /** * APIProperty: begin * {Object} Values to start the animation with */ begin: null, /** * APIProperty: finish * {Object} Values to finish the animation with */ finish: null, /** * APIProperty: duration * {int} duration of the tween (number of steps) */ duration: null, /** * APIProperty: callbacks * {Object} An object with start, eachStep and done properties whose values * are functions to be call during the animation. They are passed the * current computed value as argument. */ callbacks: null, /** * Property: time * {int} Step counter */ time: null, /** * Property: interval * {int} Interval id returned by window.setInterval */ interval: null, /** * Property: playing * {Boolean} Tells if the easing is currently playing */ playing: false, /** * Constructor: OpenLayers.Tween * Creates a Tween. * * Parameters: * easing - {(Function)} easing function method to use */ initialize: function(easing) { this.easing = (easing) ? easing : OpenLayers.Easing.Expo.easeOut; }, /** * APIMethod: start * Plays the Tween, and calls the callback method on each step * * Parameters: * begin - {Object} values to start the animation with * finish - {Object} values to finish the animation with * duration - {int} duration of the tween (number of steps) * options - {Object} hash of options (for example callbacks (start, eachStep, done)) */ start: function(begin, finish, duration, options) { this.playing = true; this.begin = begin; this.finish = finish; this.duration = duration; this.callbacks = options.callbacks; this.time = 0; if (this.interval) { window.clearInterval(this.interval); this.interval = null; } if (this.callbacks && this.callbacks.start) { this.callbacks.start.call(this, this.begin); } this.interval = window.setInterval( OpenLayers.Function.bind(this.play, this), this.INTERVAL); }, /** * APIMethod: stop * Stops the Tween, and calls the done callback * Doesn't do anything if animation is already finished */ stop: function() { if (!this.playing) { return; } if (this.callbacks && this.callbacks.done) { this.callbacks.done.call(this, this.finish); } window.clearInterval(this.interval); this.interval = null; this.playing = false; }, /** * Method: play * Calls the appropriate easing method */ play: function() { var value = {}; for (var i in this.begin) { var b = this.begin[i]; var f = this.finish[i]; if (b == null || f == null || isNaN(b) || isNaN(f)) { OpenLayers.Console.error('invalid value for Tween'); } var c = f - b; value[i] = this.easing.apply(this, [this.time, b, c, this.duration]); } this.time++; if (this.callbacks && this.callbacks.eachStep) { this.callbacks.eachStep.call(this, value); } if (this.time > this.duration) { if (this.callbacks && this.callbacks.done) { this.callbacks.done.call(this, this.finish); this.playing = false; } window.clearInterval(this.interval); this.interval = null; } }, /** * Create empty functions for all easing methods. */ CLASS_NAME: "OpenLayers.Tween" }); /** * Namespace: OpenLayers.Easing * * Credits: * Easing Equations by Robert Penner, */ OpenLayers.Easing = { /** * Create empty functions for all easing methods. */ CLASS_NAME: "OpenLayers.Easing" }; /** * Namespace: OpenLayers.Easing.Linear */ OpenLayers.Easing.Linear = { /** * Function: easeIn * * Parameters: * t - {Float} time * b - {Float} beginning position * c - {Float} total change * d - {Float} duration of the transition */ easeIn: function(t, b, c, d) { return c*t/d + b; }, /** * Function: easeOut * * Parameters: * t - {Float} time * b - {Float} beginning position * c - {Float} total change * d - {Float} duration of the transition */ easeOut: function(t, b, c, d) { return c*t/d + b; }, /** * Function: easeInOut * * Parameters: * t - {Float} time * b - {Float} beginning position * c - {Float} total change * d - {Float} duration of the transition */ easeInOut: function(t, b, c, d) { return c*t/d + b; }, CLASS_NAME: "OpenLayers.Easing.Linear" }; /** * Namespace: OpenLayers.Easing.Expo */ OpenLayers.Easing.Expo = { /** * Function: easeIn * * Parameters: * t - {Float} time * b - {Float} beginning position * c - {Float} total change * d - {Float} duration of the transition */ easeIn: function(t, b, c, d) { return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b; }, /** * Function: easeOut * * Parameters: * t - {Float} time * b - {Float} beginning position * c - {Float} total change * d - {Float} duration of the transition */ easeOut: function(t, b, c, d) { return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b; }, /** * Function: easeInOut * * Parameters: * t - {Float} time * b - {Float} beginning position * c - {Float} total change * d - {Float} duration of the transition */ easeInOut: function(t, b, c, d) { if (t==0) return b; if (t==d) return b+c; if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b; return c/2 * (-Math.pow(2, -10 * --t) + 2) + b; }, CLASS_NAME: "OpenLayers.Easing.Expo" }; /** * Namespace: OpenLayers.Easing.Quad */ OpenLayers.Easing.Quad = { /** * Function: easeIn * * Parameters: * t - {Float} time * b - {Float} beginning position * c - {Float} total change * d - {Float} duration of the transition */ easeIn: function(t, b, c, d) { return c*(t/=d)*t + b; }, /** * Function: easeOut * * Parameters: * t - {Float} time * b - {Float} beginning position * c - {Float} total change * d - {Float} duration of the transition */ easeOut: function(t, b, c, d) { return -c *(t/=d)*(t-2) + b; }, /** * Function: easeInOut * * Parameters: * t - {Float} time * b - {Float} beginning position * c - {Float} total change * d - {Float} duration of the transition */ easeInOut: function(t, b, c, d) { if ((t/=d/2) < 1) return c/2*t*t + b; return -c/2 * ((--t)*(t-2) - 1) + b; }, CLASS_NAME: "OpenLayers.Easing.Quad" }; /* ====================================================================== Rico/Color.js ====================================================================== */ /* * This file has been edited substantially from the Rico-released version by * the OpenLayers development team. * * This file is licensed under the Apache License, Version 2.0. */ OpenLayers.Rico.Color = OpenLayers.Class({ initialize: function(red, green, blue) { this.rgb = { r: red, g : green, b : blue }; }, setRed: function(r) { this.rgb.r = r; }, setGreen: function(g) { this.rgb.g = g; }, setBlue: function(b) { this.rgb.b = b; }, setHue: function(h) { // get an HSB model, and set the new hue... var hsb = this.asHSB(); hsb.h = h; // convert back to RGB... this.rgb = OpenLayers.Rico.Color.HSBtoRGB(hsb.h, hsb.s, hsb.b); }, setSaturation: function(s) { // get an HSB model, and set the new hue... var hsb = this.asHSB(); hsb.s = s; // convert back to RGB and set values... this.rgb = OpenLayers.Rico.Color.HSBtoRGB(hsb.h, hsb.s, hsb.b); }, setBrightness: function(b) { // get an HSB model, and set the new hue... var hsb = this.asHSB(); hsb.b = b; // convert back to RGB and set values... this.rgb = OpenLayers.Rico.Color.HSBtoRGB( hsb.h, hsb.s, hsb.b ); }, darken: function(percent) { var hsb = this.asHSB(); this.rgb = OpenLayers.Rico.Color.HSBtoRGB(hsb.h, hsb.s, Math.max(hsb.b - percent,0)); }, brighten: function(percent) { var hsb = this.asHSB(); this.rgb = OpenLayers.Rico.Color.HSBtoRGB(hsb.h, hsb.s, Math.min(hsb.b + percent,1)); }, blend: function(other) { this.rgb.r = Math.floor((this.rgb.r + other.rgb.r)/2); this.rgb.g = Math.floor((this.rgb.g + other.rgb.g)/2); this.rgb.b = Math.floor((this.rgb.b + other.rgb.b)/2); }, isBright: function() { var hsb = this.asHSB(); return this.asHSB().b > 0.5; }, isDark: function() { return ! this.isBright(); }, asRGB: function() { return "rgb(" + this.rgb.r + "," + this.rgb.g + "," + this.rgb.b + ")"; }, asHex: function() { return "#" + this.rgb.r.toColorPart() + this.rgb.g.toColorPart() + this.rgb.b.toColorPart(); }, asHSB: function() { return OpenLayers.Rico.Color.RGBtoHSB(this.rgb.r, this.rgb.g, this.rgb.b); }, toString: function() { return this.asHex(); } }); OpenLayers.Rico.Color.createFromHex = function(hexCode) { if(hexCode.length==4) { var shortHexCode = hexCode; var hexCode = '#'; for(var i=1;i<4;i++) { hexCode += (shortHexCode.charAt(i) + shortHexCode.charAt(i)); } } if ( hexCode.indexOf('#') == 0 ) { hexCode = hexCode.substring(1); } var red = hexCode.substring(0,2); var green = hexCode.substring(2,4); var blue = hexCode.substring(4,6); return new OpenLayers.Rico.Color( parseInt(red,16), parseInt(green,16), parseInt(blue,16) ); }; /** * Factory method for creating a color from the background of * an HTML element. */ OpenLayers.Rico.Color.createColorFromBackground = function(elem) { var actualColor = RicoUtil.getElementsComputedStyle(OpenLayers.Util.getElement(elem), "backgroundColor", "background-color"); if ( actualColor == "transparent" && elem.parentNode ) { return OpenLayers.Rico.Color.createColorFromBackground(elem.parentNode); } if ( actualColor == null ) { return new OpenLayers.Rico.Color(255,255,255); } if ( actualColor.indexOf("rgb(") == 0 ) { var colors = actualColor.substring(4, actualColor.length - 1 ); var colorArray = colors.split(","); return new OpenLayers.Rico.Color( parseInt( colorArray[0] ), parseInt( colorArray[1] ), parseInt( colorArray[2] ) ); } else if ( actualColor.indexOf("#") == 0 ) { return OpenLayers.Rico.Color.createFromHex(actualColor); } else { return new OpenLayers.Rico.Color(255,255,255); } }; OpenLayers.Rico.Color.HSBtoRGB = function(hue, saturation, brightness) { var red = 0; var green = 0; var blue = 0; if (saturation == 0) { red = parseInt(brightness * 255.0 + 0.5); green = red; blue = red; } else { var h = (hue - Math.floor(hue)) * 6.0; var f = h - Math.floor(h); var p = brightness * (1.0 - saturation); var q = brightness * (1.0 - saturation * f); var t = brightness * (1.0 - (saturation * (1.0 - f))); switch (parseInt(h)) { case 0: red = (brightness * 255.0 + 0.5); green = (t * 255.0 + 0.5); blue = (p * 255.0 + 0.5); break; case 1: red = (q * 255.0 + 0.5); green = (brightness * 255.0 + 0.5); blue = (p * 255.0 + 0.5); break; case 2: red = (p * 255.0 + 0.5); green = (brightness * 255.0 + 0.5); blue = (t * 255.0 + 0.5); break; case 3: red = (p * 255.0 + 0.5); green = (q * 255.0 + 0.5); blue = (brightness * 255.0 + 0.5); break; case 4: red = (t * 255.0 + 0.5); green = (p * 255.0 + 0.5); blue = (brightness * 255.0 + 0.5); break; case 5: red = (brightness * 255.0 + 0.5); green = (p * 255.0 + 0.5); blue = (q * 255.0 + 0.5); break; } } return { r : parseInt(red), g : parseInt(green) , b : parseInt(blue) }; }; OpenLayers.Rico.Color.RGBtoHSB = function(r, g, b) { var hue; var saturation; var brightness; var cmax = (r > g) ? r : g; if (b > cmax) { cmax = b; } var cmin = (r < g) ? r : g; if (b < cmin) { cmin = b; } brightness = cmax / 255.0; if (cmax != 0) { saturation = (cmax - cmin)/cmax; } else { saturation = 0; } if (saturation == 0) { hue = 0; } else { var redc = (cmax - r)/(cmax - cmin); var greenc = (cmax - g)/(cmax - cmin); var bluec = (cmax - b)/(cmax - cmin); if (r == cmax) { hue = bluec - greenc; } else if (g == cmax) { hue = 2.0 + redc - bluec; } else { hue = 4.0 + greenc - redc; } hue = hue / 6.0; if (hue < 0) { hue = hue + 1.0; } } return { h : hue, s : saturation, b : brightness }; }; /* ====================================================================== OpenLayers/Control/ArgParser.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.ArgParser * * Inherits from: * - */ OpenLayers.Control.ArgParser = OpenLayers.Class(OpenLayers.Control, { /** * Parameter: center * {} */ center: null, /** * Parameter: zoom * {int} */ zoom: null, /** * Parameter: layers * {Array()} */ layers: null, /** * APIProperty: displayProjection * {} Requires proj4js support. * Projection used when reading the coordinates from the URL. This will * reproject the map coordinates from the URL into the map's * projection. * * If you are using this functionality, be aware that any permalink * which is added to the map will determine the coordinate type which * is read from the URL, which means you should not add permalinks with * different displayProjections to the same map. */ displayProjection: null, /** * Constructor: OpenLayers.Control.ArgParser * * Parameters: * options - {Object} */ initialize: function(options) { OpenLayers.Control.prototype.initialize.apply(this, arguments); }, /** * Method: setMap * Set the map property for the control. * * Parameters: * map - {} */ setMap: function(map) { OpenLayers.Control.prototype.setMap.apply(this, arguments); //make sure we dont already have an arg parser attached for(var i=0; i< this.map.controls.length; i++) { var control = this.map.controls[i]; if ( (control != this) && (control.CLASS_NAME == "OpenLayers.Control.ArgParser") ) { // If a second argparser is added to the map, then we // override the displayProjection to be the one added to the // map. if (control.displayProjection != this.displayProjection) { this.displayProjection = control.displayProjection; } break; } } if (i == this.map.controls.length) { var args = OpenLayers.Util.getParameters(); // Be careful to set layer first, to not trigger unnecessary layer loads if (args.layers) { this.layers = args.layers; // when we add a new layer, set its visibility this.map.events.register('addlayer', this, this.configureLayers); this.configureLayers(); } if (args.lat && args.lon) { this.center = new OpenLayers.LonLat(parseFloat(args.lon), parseFloat(args.lat)); if (args.zoom) { this.zoom = parseInt(args.zoom); } // when we add a new baselayer to see when we can set the center this.map.events.register('changebaselayer', this, this.setCenter); this.setCenter(); } } }, /** * Method: setCenter * As soon as a baseLayer has been loaded, we center and zoom * ...and remove the handler. */ setCenter: function() { if (this.map.baseLayer) { //dont need to listen for this one anymore this.map.events.unregister('changebaselayer', this, this.setCenter); if (this.displayProjection) { this.center.transform(this.displayProjection, this.map.getProjectionObject()); } this.map.setCenter(this.center, this.zoom); } }, /** * Method: configureLayers * As soon as all the layers are loaded, cycle through them and * hide or show them. */ configureLayers: function() { if (this.layers.length == this.map.layers.length) { this.map.events.unregister('addlayer', this, this.configureLayers); for(var i=0; i < this.layers.length; i++) { var layer = this.map.layers[i]; var c = this.layers.charAt(i); if (c == "B") { this.map.setBaseLayer(layer); } else if ( (c == "T") || (c == "F") ) { layer.setVisibility(c == "T"); } } } }, CLASS_NAME: "OpenLayers.Control.ArgParser" }); /* ====================================================================== OpenLayers/Control/Attribution.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.Attribution * Add attribution from layers to the map display. Uses 'attribution' property * of each layer. */ OpenLayers.Control.Attribution = OpenLayers.Class(OpenLayers.Control, { /** * APIProperty: seperator * {String} String used to seperate layers. */ separator: ", ", /** * Constructor: OpenLayers.Control.Attribution * * Parameters: * options - {Object} Options for control. */ initialize: function(options) { OpenLayers.Control.prototype.initialize.apply(this, arguments); }, /** * Method: destroy * Destroy control. */ destroy: function() { this.map.events.un({ "removelayer": this.updateAttribution, "addlayer": this.updateAttribution, "changelayer": this.updateAttribution, "changebaselayer": this.updateAttribution, scope: this }); OpenLayers.Control.prototype.destroy.apply(this, arguments); }, /** * Method: draw * Initialize control. * * Returns: * {DOMElement} A reference to the DIV DOMElement containing the control */ draw: function() { OpenLayers.Control.prototype.draw.apply(this, arguments); this.map.events.on({ 'changebaselayer': this.updateAttribution, 'changelayer': this.updateAttribution, 'addlayer': this.updateAttribution, 'removelayer': this.updateAttribution, scope: this }); this.updateAttribution(); return this.div; }, /** * Method: updateAttribution * Update attribution string. */ updateAttribution: function() { var attributions = []; if (this.map && this.map.layers) { for(var i=0; i < this.map.layers.length; i++) { var layer = this.map.layers[i]; if (layer.attribution && layer.getVisibility()) { attributions.push( layer.attribution ); } } this.div.innerHTML = attributions.join(this.separator); } }, CLASS_NAME: "OpenLayers.Control.Attribution" }); /* ====================================================================== OpenLayers/Control/Button.js ====================================================================== */ /* Copyright (c) 2006-2007 MetaCarta, Inc., published under a modified BSD license. * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt * for the full text of the license. */ /** * @requires OpenLayers/Control.js */ /** * Class: OpenLayers.Control.Button * A very simple button controlfor use with . * When clicked, the function trigger() is executed. * * Inherits from: * - * * Use: * (code) * var button = new OpenLayers.Control.Button({ * displayClass: "MyButton", trigger: myFunction * }); * panel.addControls([button]); * (end) * * Will create a button with CSS class MyButtonItemInactive, that * will call the function MyFunction() when clicked. */ OpenLayers.Control.Button = OpenLayers.Class(OpenLayers.Control, { /** * Property: type * {Integer} OpenLayers.Control.TYPE_BUTTON. */ type: OpenLayers.Control.TYPE_BUTTON, /** * Method: trigger * Called by a control panel when the button is clicked. */ trigger: function() {}, CLASS_NAME: "OpenLayers.Control.Button" }); /* ====================================================================== OpenLayers/Control/LayerSwitcher.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.LayerSwitcher * * Inherits from: * - */ OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, { /** * Property: activeColor * {String} */ activeColor: "darkblue", /** * Property: layerStates * {Array(Object)} Basically a copy of the "state" of the map's layers * the last time the control was drawn. We have this in order to avoid * unnecessarily redrawing the control. */ layerStates: null, // DOM Elements /** * Property: layersDiv * {DOMElement} */ layersDiv: null, /** * Property: baseLayersDiv * {DOMElement} */ baseLayersDiv: null, /** * Property: baseLayers * {Array()} */ baseLayers: null, /** * Property: dataLbl * {DOMElement} */ dataLbl: null, /** * Property: dataLayersDiv * {DOMElement} */ dataLayersDiv: null, /** * Property: dataLayers * {Array()} */ dataLayers: null, /** * Property: minimizeDiv * {DOMElement} */ minimizeDiv: null, /** * Property: maximizeDiv * {DOMElement} */ maximizeDiv: null, /** * APIProperty: ascending * {Boolean} */ ascending: true, /** * Constructor: OpenLayers.Control.LayerSwitcher * * Parameters: * options - {Object} */ initialize: function(options) { OpenLayers.Control.prototype.initialize.apply(this, arguments); this.layerStates = []; }, /** * APIMethod: destroy */ destroy: function() { OpenLayers.Event.stopObservingElement(this.div); OpenLayers.Event.stopObservingElement(this.minimizeDiv); OpenLayers.Event.stopObservingElement(this.maximizeDiv); //clear out layers info and unregister their events this.clearLayersArray("base"); this.clearLayersArray("data"); this.map.events.un({ "addlayer": this.redraw, "changelayer": this.redraw, "removelayer": this.redraw, "changebaselayer": this.redraw, scope: this }); OpenLayers.Control.prototype.destroy.apply(this, arguments); }, /** * Method: setMap * * Properties: * map - {} */ setMap: function(map) { OpenLayers.Control.prototype.setMap.apply(this, arguments); this.map.events.on({ "addlayer": this.redraw, "changelayer": this.redraw, "removelayer": this.redraw, "changebaselayer": this.redraw, scope: this }); }, /** * Method: draw * * Returns: * {DOMElement} A reference to the DIV DOMElement containing the * switcher tabs. */ draw: function() { OpenLayers.Control.prototype.draw.apply(this); // create layout divs this.loadContents(); // set mode to minimize if(!this.outsideViewport) { this.minimizeControl(); } // populate div with current info this.redraw(); return this.div; }, /** * Method: clearLayersArray * User specifies either "base" or "data". we then clear all the * corresponding listeners, the div, and reinitialize a new array. * * Parameters: * layersType - {String} */ clearLayersArray: function(layersType) { var layers = this[layersType + "Layers"]; if (layers) { for(var i=0; i < layers.length; i++) { var layer = layers[i]; OpenLayers.Event.stopObservingElement(layer.inputElem); OpenLayers.Event.stopObservingElement(layer.labelSpan); } } this[layersType + "LayersDiv"].innerHTML = ""; this[layersType + "Layers"] = []; }, /** * Method: checkRedraw * Checks if the layer state has changed since the last redraw() call. * * Returns: * {Boolean} The layer state changed since the last redraw() call. */ checkRedraw: function() { var redraw = false; if ( !this.layerStates.length || (this.map.layers.length != this.layerStates.length) ) { redraw = true; } else { for (var i=0; i < this.layerStates.length; i++) { var layerState = this.layerStates[i]; var layer = this.map.layers[i]; if ( (layerState.name != layer.name) || (layerState.inRange != layer.inRange) || (layerState.id != layer.id) || (layerState.visibility != layer.visibility) ) { redraw = true; break; } } } return redraw; }, /** * Method: redraw * Goes through and takes the current state of the Map and rebuilds the * control to display that state. Groups base layers into a * radio-button group and lists each data layer with a checkbox. * * Returns: * {DOMElement} A reference to the DIV DOMElement containing the control */ redraw: function() { //if the state hasn't changed since last redraw, no need // to do anything. Just return the existing div. if (!this.checkRedraw()) { return this.div; } //clear out previous layers this.clearLayersArray("base"); this.clearLayersArray("data"); var containsOverlays = false; var containsBaseLayers = false; // Save state -- for checking layer if the map state changed. // We save this before redrawing, because in the process of redrawing // we will trigger more visibility changes, and we want to not redraw // and enter an infinite loop. this.layerStates = new Array(this.map.layers.length); for (var i = 0; i < this.map.layers.length; i++) { var layer = this.map.layers[i]; this.layerStates[i] = { 'name': layer.name, 'visibility': layer.visibility, 'inRange': layer.inRange, 'id': layer.id }; } var layers = this.map.layers.slice(); if (!this.ascending) { layers.reverse(); } for( var i = 0; i < layers.length; i++) { var layer = layers[i]; var baseLayer = layer.isBaseLayer; if (layer.displayInLayerSwitcher) { if (baseLayer) { containsBaseLayers = true; } else { containsOverlays = true; } // only check a baselayer if it is *the* baselayer, check data // layers if they are visible var checked = (baseLayer) ? (layer == this.map.baseLayer) : layer.getVisibility(); // create input element var inputElem = document.createElement("input"); inputElem.id = "input_" + layer.name; inputElem.name = (baseLayer) ? "baseLayers" : layer.name; inputElem.type = (baseLayer) ? "radio" : "checkbox"; inputElem.value = layer.name; inputElem.checked = checked; inputElem.defaultChecked = checked; if (!baseLayer && !layer.inRange) { inputElem.disabled = true; } var context = { 'inputElem': inputElem, 'layer': layer, 'layerSwitcher': this }; OpenLayers.Event.observe(inputElem, "mouseup", OpenLayers.Function.bindAsEventListener(this.onInputClick, context) ); // create span var labelSpan = document.createElement("span"); if (!baseLayer && !layer.inRange) { labelSpan.style.color = "gray"; } labelSpan.innerHTML = layer.name; labelSpan.style.verticalAlign = (baseLayer) ? "bottom" : "baseline"; OpenLayers.Event.observe(labelSpan, "click", OpenLayers.Function.bindAsEventListener(this.onInputClick, context) ); // create line break var br = document.createElement("br"); var groupArray = (baseLayer) ? this.baseLayers : this.dataLayers; groupArray.push({ 'layer': layer, 'inputElem': inputElem, 'labelSpan': labelSpan }); var groupDiv = (baseLayer) ? this.baseLayersDiv : this.dataLayersDiv; groupDiv.appendChild(inputElem); groupDiv.appendChild(labelSpan); groupDiv.appendChild(br); } } // if no overlays, dont display the overlay label this.dataLbl.style.display = (containsOverlays) ? "" : "none"; // if no baselayers, dont display the baselayer label this.baseLbl.style.display = (containsBaseLayers) ? "" : "none"; return this.div; }, /** * Method: * A label has been clicked, check or uncheck its corresponding input * * Parameters: * e - {Event} * * Context: * - {DOMElement} inputElem * - {} layerSwitcher * - {} layer */ onInputClick: function(e) { if (!this.inputElem.disabled) { if (this.inputElem.type == "radio") { this.inputElem.checked = true; this.layer.map.setBaseLayer(this.layer); } else { this.inputElem.checked = !this.inputElem.checked; this.layerSwitcher.updateMap(); } } OpenLayers.Event.stop(e); }, /** * Method: onLayerClick * Need to update the map accordingly whenever user clicks in either of * the layers. * * Parameters: * e - {Event} */ onLayerClick: function(e) { this.updateMap(); }, /** * Method: updateMap * Cycles through the loaded data and base layer input arrays and makes * the necessary calls to the Map object such that that the map's * visual state corresponds to what the user has selected in * the control. */ updateMap: function() { // set the newly selected base layer for(var i=0; i < this.baseLayers.length; i++) { var layerEntry = this.baseLayers[i]; if (layerEntry.inputElem.checked) { this.map.setBaseLayer(layerEntry.layer, false); } } // set the correct visibilities for the overlays for(var i=0; i < this.dataLayers.length; i++) { var layerEntry = this.dataLayers[i]; layerEntry.layer.setVisibility(layerEntry.inputElem.checked); } }, /** * Method: maximizeControl * Set up the labels and divs for the control * * Parameters: * e - {Event} */ maximizeControl: function(e) { //HACK HACK HACK - find a way to auto-size this layerswitcher this.div.style.width = "20em"; this.div.style.height = ""; this.showControls(false); if (e != null) { OpenLayers.Event.stop(e); } }, /** * Method: minimizeControl * Hide all the contents of the control, shrink the size, * add the maximize icon * * Parameters: * e - {Event} */ minimizeControl: function(e) { this.div.style.width = "0px"; this.div.style.height = "0px"; this.showControls(true); if (e != null) { OpenLayers.Event.stop(e); } }, /** * Method: showControls * Hide/Show all LayerSwitcher controls depending on whether we are * minimized or not * * Parameters: * minimize - {Boolean} */ showControls: function(minimize) { this.maximizeDiv.style.display = minimize ? "" : "none"; this.minimizeDiv.style.display = minimize ? "none" : ""; this.layersDiv.style.display = minimize ? "none" : ""; }, /** * Method: loadContents * Set up the labels and divs for the control */ loadContents: function() { //configure main div this.div.style.position = "absolute"; this.div.style.top = "25px"; this.div.style.right = "0px"; this.div.style.left = ""; this.div.style.fontFamily = "sans-serif"; this.div.style.fontWeight = "bold"; this.div.style.marginTop = "3px"; this.div.style.marginLeft = "3px"; this.div.style.marginBottom = "3px"; this.div.style.fontSize = "smaller"; this.div.style.color = "white"; this.div.style.backgroundColor = "transparent"; OpenLayers.Event.observe(this.div, "mouseup", OpenLayers.Function.bindAsEventListener(this.mouseUp, this)); OpenLayers.Event.observe(this.div, "click", this.ignoreEvent); OpenLayers.Event.observe(this.div, "mousedown", OpenLayers.Function.bindAsEventListener(this.mouseDown, this)); OpenLayers.Event.observe(this.div, "dblclick", this.ignoreEvent); // layers list div this.layersDiv = document.createElement("div"); this.layersDiv.id = "layersDiv"; this.layersDiv.style.paddingTop = "5px"; this.layersDiv.style.paddingLeft = "10px"; this.layersDiv.style.paddingBottom = "5px"; this.layersDiv.style.paddingRight = "75px"; this.layersDiv.style.backgroundColor = this.activeColor; // had to set width/height to get transparency in IE to work. // thanks -- http://jszen.blogspot.com/2005/04/ie6-opacity-filter-caveat.html // this.layersDiv.style.width = "100%"; this.layersDiv.style.height = "100%"; this.baseLbl = document.createElement("div"); this.baseLbl.innerHTML = OpenLayers.i18n("baseLayer"); this.baseLbl.style.marginTop = "3px"; this.baseLbl.style.marginLeft = "3px"; this.baseLbl.style.marginBottom = "3px"; this.baseLayersDiv = document.createElement("div"); this.baseLayersDiv.style.paddingLeft = "10px"; /*OpenLayers.Event.observe(this.baseLayersDiv, "click", OpenLayers.Function.bindAsEventListener(this.onLayerClick, this)); */ this.dataLbl = document.createElement("div"); this.dataLbl.innerHTML = OpenLayers.i18n("overlays"); this.dataLbl.style.marginTop = "3px"; this.dataLbl.style.marginLeft = "3px"; this.dataLbl.style.marginBottom = "3px"; this.dataLayersDiv = document.createElement("div"); this.dataLayersDiv.style.paddingLeft = "10px"; if (this.ascending) { this.layersDiv.appendChild(this.baseLbl); this.layersDiv.appendChild(this.baseLayersDiv); this.layersDiv.appendChild(this.dataLbl); this.layersDiv.appendChild(this.dataLayersDiv); } else { this.layersDiv.appendChild(this.dataLbl); this.layersDiv.appendChild(this.dataLayersDiv); this.layersDiv.appendChild(this.baseLbl); this.layersDiv.appendChild(this.baseLayersDiv); } this.div.appendChild(this.layersDiv); OpenLayers.Rico.Corner.round(this.div, {corners: "tl bl", bgColor: "transparent", color: this.activeColor, blend: false}); OpenLayers.Rico.Corner.changeOpacity(this.layersDiv, 0.75); var imgLocation = OpenLayers.Util.getImagesLocation(); var sz = new OpenLayers.Size(18,18); // maximize button div var img = imgLocation + 'layer-switcher-maximize.png'; this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv( "OpenLayers_Control_MaximizeDiv", null, sz, img, "absolute"); this.maximizeDiv.style.top = "5px"; this.maximizeDiv.style.right = "0px"; this.maximizeDiv.style.left = ""; this.maximizeDiv.style.display = "none"; OpenLayers.Event.observe(this.maximizeDiv, "click", OpenLayers.Function.bindAsEventListener(this.maximizeControl, this) ); this.div.appendChild(this.maximizeDiv); // minimize button div var img = imgLocation + 'layer-switcher-minimize.png'; var sz = new OpenLayers.Size(18,18); this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv( "OpenLayers_Control_MinimizeDiv", null, sz, img, "absolute"); this.minimizeDiv.style.top = "5px"; this.minimizeDiv.style.right = "0px"; this.minimizeDiv.style.left = ""; this.minimizeDiv.style.display = "none"; OpenLayers.Event.observe(this.minimizeDiv, "click", OpenLayers.Function.bindAsEventListener(this.minimizeControl, this) ); this.div.appendChild(this.minimizeDiv); }, /** * Method: ignoreEvent * * Parameters: * evt - {Event} */ ignoreEvent: function(evt) { OpenLayers.Event.stop(evt); }, /** * Method: mouseDown * Register a local 'mouseDown' flag so that we'll know whether or not * to ignore a mouseUp event * * Parameters: * evt - {Event} */ mouseDown: function(evt) { this.isMouseDown = true; this.ignoreEvent(evt); }, /** * Method: mouseUp * If the 'isMouseDown' flag has been set, that means that the drag was * started from within the LayerSwitcher control, and thus we can * ignore the mouseup. Otherwise, let the Event continue. * * Parameters: * evt - {Event} */ mouseUp: function(evt) { if (this.isMouseDown) { this.isMouseDown = false; this.ignoreEvent(evt); } }, CLASS_NAME: "OpenLayers.Control.LayerSwitcher" }); /* ====================================================================== OpenLayers/Control/MouseDefaults.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.MouseDefaults * * Inherits from: * - */ OpenLayers.Control.MouseDefaults = OpenLayers.Class(OpenLayers.Control, { /** WARNING WARNING WARNING!!! This class is DEPRECATED in 2.4 and will be removed by 3.0. If you need this functionality, use Control.Navigation instead!!! */ /** * Property: performedDrag * {Boolean} */ performedDrag: false, /** * Property: wheelObserver * {Function} */ wheelObserver: null, /** * Constructor: OpenLayers.Control.MouseDefaults */ initialize: function() { OpenLayers.Control.prototype.initialize.apply(this, arguments); }, /** * APIMethod: destroy */ destroy: function() { if (this.handler) { this.handler.destroy(); } this.handler = null; this.map.events.un({ "click": this.defaultClick, "dblclick": this.defaultDblClick, "mousedown": this.defaultMouseDown, "mouseup": this.defaultMouseUp, "mousemove": this.defaultMouseMove, "mouseout": this.defaultMouseOut, scope: this }); //unregister mousewheel events specifically on the window and document OpenLayers.Event.stopObserving(window, "DOMMouseScroll", this.wheelObserver); OpenLayers.Event.stopObserving(window, "mousewheel", this.wheelObserver); OpenLayers.Event.stopObserving(document, "mousewheel", this.wheelObserver); this.wheelObserver = null; OpenLayers.Control.prototype.destroy.apply(this, arguments); }, /** * Method: draw */ draw: function() { this.map.events.on({ "click": this.defaultClick, "dblclick": this.defaultDblClick, "mousedown": this.defaultMouseDown, "mouseup": this.defaultMouseUp, "mousemove": this.defaultMouseMove, "mouseout": this.defaultMouseOut, scope: this }); this.registerWheelEvents(); }, /** * Method: registerWheelEvents */ registerWheelEvents: function() { this.wheelObserver = OpenLayers.Function.bindAsEventListener( this.onWheelEvent, this ); //register mousewheel events specifically on the window and document OpenLayers.Event.observe(window, "DOMMouseScroll", this.wheelObserver); OpenLayers.Event.observe(window, "mousewheel", this.wheelObserver); OpenLayers.Event.observe(document, "mousewheel", this.wheelObserver); }, /** * Method: defaultClick * * Parameters: * evt - {Event} * * Returns: * {Boolean} */ defaultClick: function (evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } var notAfterDrag = !this.performedDrag; this.performedDrag = false; return notAfterDrag; }, /** * Method: defaultDblClick * * Parameters: * evt - {Event} */ defaultDblClick: function (evt) { var newCenter = this.map.getLonLatFromViewPortPx( evt.xy ); this.map.setCenter(newCenter, this.map.zoom + 1); OpenLayers.Event.stop(evt); return false; }, /** * Method: defaultMouseDown * * Parameters: * evt - {Event} */ defaultMouseDown: function (evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } this.mouseDragStart = evt.xy.clone(); this.performedDrag = false; if (evt.shiftKey) { this.map.div.style.cursor = "crosshair"; this.zoomBox = OpenLayers.Util.createDiv('zoomBox', this.mouseDragStart, null, null, "absolute", "2px solid red"); this.zoomBox.style.backgroundColor = "white"; this.zoomBox.style.filter = "alpha(opacity=50)"; // IE this.zoomBox.style.opacity = "0.50"; this.zoomBox.style.fontSize = "1px"; this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; this.map.viewPortDiv.appendChild(this.zoomBox); } document.onselectstart=function() { return false; }; OpenLayers.Event.stop(evt); }, /** * Method: defaultMouseMove * * Parameters: * evt - {Event} */ defaultMouseMove: function (evt) { // record the mouse position, used in onWheelEvent this.mousePosition = evt.xy.clone(); if (this.mouseDragStart != null) { if (this.zoomBox) { var deltaX = Math.abs(this.mouseDragStart.x - evt.xy.x); var deltaY = Math.abs(this.mouseDragStart.y - evt.xy.y); this.zoomBox.style.width = Math.max(1, deltaX) + "px"; this.zoomBox.style.height = Math.max(1, deltaY) + "px"; if (evt.xy.x < this.mouseDragStart.x) { this.zoomBox.style.left = evt.xy.x+"px"; } if (evt.xy.y < this.mouseDragStart.y) { this.zoomBox.style.top = evt.xy.y+"px"; } } else { var deltaX = this.mouseDragStart.x - evt.xy.x; var deltaY = this.mouseDragStart.y - evt.xy.y; var size = this.map.getSize(); var newXY = new OpenLayers.Pixel(size.w / 2 + deltaX, size.h / 2 + deltaY); var newCenter = this.map.getLonLatFromViewPortPx( newXY ); this.map.setCenter(newCenter, null, true); this.mouseDragStart = evt.xy.clone(); this.map.div.style.cursor = "move"; } this.performedDrag = true; } }, /** * Method: defaultMouseUp * * Parameters: * evt - {} */ defaultMouseUp: function (evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } if (this.zoomBox) { this.zoomBoxEnd(evt); } else { if (this.performedDrag) { this.map.setCenter(this.map.center); } } document.onselectstart=null; this.mouseDragStart = null; this.map.div.style.cursor = ""; }, /** * Method: defaultMouseOut * * Parameters: * evt - {Event} */ defaultMouseOut: function (evt) { if (this.mouseDragStart != null && OpenLayers.Util.mouseLeft(evt, this.map.div)) { if (this.zoomBox) { this.removeZoomBox(); } this.mouseDragStart = null; } }, /** * Method: defaultWheelUp * User spun scroll wheel up * */ defaultWheelUp: function(evt) { if (this.map.getZoom() <= this.map.getNumZoomLevels()) { this.map.setCenter(this.map.getLonLatFromPixel(evt.xy), this.map.getZoom() + 1); } }, /** * Method: defaultWheelDown * User spun scroll wheel down */ defaultWheelDown: function(evt) { if (this.map.getZoom() > 0) { this.map.setCenter(this.map.getLonLatFromPixel(evt.xy), this.map.getZoom() - 1); } }, /** * Method: zoomBoxEnd * Zoombox function. */ zoomBoxEnd: function(evt) { if (this.mouseDragStart != null) { if (Math.abs(this.mouseDragStart.x - evt.xy.x) > 5 || Math.abs(this.mouseDragStart.y - evt.xy.y) > 5) { var start = this.map.getLonLatFromViewPortPx( this.mouseDragStart ); var end = this.map.getLonLatFromViewPortPx( evt.xy ); var top = Math.max(start.lat, end.lat); var bottom = Math.min(start.lat, end.lat); var left = Math.min(start.lon, end.lon); var right = Math.max(start.lon, end.lon); var bounds = new OpenLayers.Bounds(left, bottom, right, top); this.map.zoomToExtent(bounds); } else { var end = this.map.getLonLatFromViewPortPx( evt.xy ); this.map.setCenter(new OpenLayers.LonLat( (end.lon), (end.lat) ), this.map.getZoom() + 1); } this.removeZoomBox(); } }, /** * Method: removeZoomBox * Remove the zoombox from the screen and nullify our reference to it. */ removeZoomBox: function() { this.map.viewPortDiv.removeChild(this.zoomBox); this.zoomBox = null; }, /** * Mouse ScrollWheel code thanks to http://adomas.org/javascript-mouse-wheel/ */ /** * Method: onWheelEvent * Catch the wheel event and handle it xbrowserly * * Parameters: * e - {Event} */ onWheelEvent: function(e){ // first determine whether or not the wheeling was inside the map var inMap = false; var elem = OpenLayers.Event.element(e); while(elem != null) { if (this.map && elem == this.map.div) { inMap = true; break; } elem = elem.parentNode; } if (inMap) { var delta = 0; if (!e) { e = window.event; } if (e.wheelDelta) { delta = e.wheelDelta/120; if (window.opera && window.opera.version() < 9.2) { delta = -delta; } } else if (e.detail) { delta = -e.detail / 3; } if (delta) { // add the mouse position to the event because mozilla has a bug // with clientX and clientY (see https://bugzilla.mozilla.org/show_bug.cgi?id=352179) // getLonLatFromViewPortPx(e) returns wrong values e.xy = this.mousePosition; if (delta < 0) { this.defaultWheelDown(e); } else { this.defaultWheelUp(e); } } //only wheel the map, not the window OpenLayers.Event.stop(e); } }, CLASS_NAME: "OpenLayers.Control.MouseDefaults" }); /* ====================================================================== OpenLayers/Control/MousePosition.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.MousePosition */ OpenLayers.Control.MousePosition = OpenLayers.Class(OpenLayers.Control, { /** * Property: element * {DOMElement} */ element: null, /** * APIProperty: prefix * {String} */ prefix: '', /** * APIProperty: separator * {String} */ separator: ', ', /** * APIProperty: suffix * {String} */ suffix: '', /** * APIProperty: numDigits * {Integer} */ numdigits: 5, /** * APIProperty: granularity * {Integer} */ granularity: 10, /** * Property: lastXy * {} */ lastXy: null, /** * APIProperty: displayProjection * {} A projection that the * mousecontrol will display. */ displayProjection: null, /** * Constructor: OpenLayers.Control.MousePosition * * Parameters: * options - {DOMElement} Options for control. */ initialize: function(options) { OpenLayers.Control.prototype.initialize.apply(this, arguments); }, /** * Method: destroy */ destroy: function() { if (this.map) { this.map.events.unregister('mousemove', this, this.redraw); } OpenLayers.Control.prototype.destroy.apply(this, arguments); }, /** * Method: draw * {DOMElement} */ draw: function() { OpenLayers.Control.prototype.draw.apply(this, arguments); if (!this.element) { this.div.left = ""; this.div.top = ""; this.element = this.div; } this.redraw(); return this.div; }, /** * Method: redraw */ redraw: function(evt) { var lonLat; if (evt == null) { lonLat = new OpenLayers.LonLat(0, 0); } else { if (this.lastXy == null || Math.abs(evt.xy.x - this.lastXy.x) > this.granularity || Math.abs(evt.xy.y - this.lastXy.y) > this.granularity) { this.lastXy = evt.xy; return; } lonLat = this.map.getLonLatFromPixel(evt.xy); if (!lonLat) { // map has not yet been properly initialized return; } if (this.displayProjection) { lonLat.transform(this.map.getProjectionObject(), this.displayProjection ); } this.lastXy = evt.xy; } var newHtml = this.formatOutput(lonLat); if (newHtml != this.element.innerHTML) { this.element.innerHTML = newHtml; } }, /** * Method: formatOutput * Override to provide custom display output * * Parameters: * lonLat - {} Location to display */ formatOutput: function(lonLat) { var digits = parseInt(this.numdigits); var newHtml = this.prefix + lonLat.lon.toFixed(digits) + this.separator + lonLat.lat.toFixed(digits) + this.suffix; return newHtml; }, /** * Method: setMap */ setMap: function() { OpenLayers.Control.prototype.setMap.apply(this, arguments); this.map.events.register( 'mousemove', this, this.redraw); }, CLASS_NAME: "OpenLayers.Control.MousePosition" }); /* ====================================================================== OpenLayers/Control/NavigationHistory.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.NavigationHistory * A navigation history control. This is a meta-control, that creates two * dependent controls: and . Call the trigger method * on the and controls to restore previous and next * history states. The previous and next controls will become active * when there are available states to restore and will become deactive * when there are no states to restore. * * Inherits from: * - */ OpenLayers.Control.NavigationHistory = OpenLayers.Class(OpenLayers.Control, { /** * Property: type * {String} Note that this control is not intended to be added directly * to a control panel. Instead, add the sub-controls previous and * next. These sub-controls are button type controls that activate * and deactivate themselves. If this parent control is added to * a panel, it will act as a toggle. */ type: OpenLayers.Control.TYPE_TOGGLE, /** * APIProperty: previous * {} A button type control whose trigger method restores * the previous state managed by this control. */ previous: null, /** * APIProperty: previousOptions * {Object} Set this property on the options argument of the constructor * to set optional properties on the control. */ previousOptions: null, /** * APIProperty: next * {} A button type control whose trigger method restores * the next state managed by this control. */ next: null, /** * APIProperty: nextOptions * {Object} Set this property on the options argument of the constructor * to set optional properties on the control. */ nextOptions: null, /** * APIProperty: limit * {Integer} Optional limit on the number of history items to retain. If * null, there is no limit. Default is 50. */ limit: 50, /** * Property: activateOnDraw * {Boolean} Activate the control when it is first added to the map. * Default is true. */ activateOnDraw: true, /** * Property: clearOnDeactivate * {Boolean} Clear the history when the control is deactivated. Default * is false. */ clearOnDeactivate: false, /** * Property: registry * {Object} An object with keys corresponding to event types. Values * are functions that return an object representing the current state. */ registry: null, /** * Property: nextStack * {Array} Array of items in the history. */ nextStack: null, /** * Property: previousStack * {Array} List of items in the history. First item represents the current * state. */ previousStack: null, /** * Property: listeners * {Object} An object containing properties corresponding to event types. * This object is used to configure the control and is modified on * construction. */ listeners: null, /** * Property: restoring * {Boolean} Currently restoring a history state. This is set to true * before calling restore and set to false after restore returns. */ restoring: false, /** * Constructor: OpenLayers.Control.NavigationHistory * * 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.registry = OpenLayers.Util.extend({ "moveend": function() { return { center: this.map.getCenter(), resolution: this.map.getResolution() }; } }, this.registry); this.clear(); var previousOptions = { trigger: OpenLayers.Function.bind(this.previousTrigger, this), displayClass: this.displayClass + "Previous" }; OpenLayers.Util.extend(previousOptions, this.previousOptions); this.previous = new OpenLayers.Control.Button(previousOptions); var nextOptions = { trigger: OpenLayers.Function.bind(this.nextTrigger, this), displayClass: this.displayClass + "Next" }; OpenLayers.Util.extend(nextOptions, this.nextOptions); this.next = new OpenLayers.Control.Button(nextOptions); }, /** * Method: onPreviousChange * Called when the previous history stack changes. * * Parameters: * state - {Object} An object representing the state to be restored * if previous is triggered again or null if no previous states remain. * length - {Integer} The number of remaining previous states that can * be restored. */ onPreviousChange: function(state, length) { if(state && !this.previous.active) { this.previous.activate(); } else if(!state && this.previous.active) { this.previous.deactivate(); } }, /** * Method: onNextChange * Called when the next history stack changes. * * Parameters: * state - {Object} An object representing the state to be restored * if next is triggered again or null if no next states remain. * length - {Integer} The number of remaining next states that can * be restored. */ onNextChange: function(state, length) { if(state && !this.next.active) { this.next.activate(); } else if(!state && this.next.active) { this.next.deactivate(); } }, /** * APIMethod: destroy * Destroy the control. */ destroy: function() { OpenLayers.Control.prototype.destroy.apply(this); this.previous.destroy(); this.next.destroy(); this.deactivate(); for(var prop in this) { this[prop] = null; } }, /** * Method: setMap * Set the map property for the control and and child * controls. * * Parameters: * map - {} */ setMap: function(map) { this.map = map; this.next.setMap(map); this.previous.setMap(map); }, /** * Method: draw * Called when the control is added to the map. */ draw: function() { OpenLayers.Control.prototype.draw.apply(this, arguments); this.next.draw(); this.previous.draw(); if(this.activateOnDraw) { this.activate(); } }, /** * Method: previousTrigger * Restore the previous state. If no items are in the previous history * stack, this has no effect. * * Returns: * {Object} Item representing state that was restored. Undefined if no * items are in the previous history stack. */ previousTrigger: function() { var current = this.previousStack.shift(); var state = this.previousStack.shift(); if(state != undefined) { this.nextStack.unshift(current); this.previousStack.unshift(state); this.restoring = true; this.restore(state); this.restoring = false; this.onNextChange(this.nextStack[0], this.nextStack.length); this.onPreviousChange( this.previousStack[1], this.previousStack.length - 1 ); } else { this.previousStack.unshift(current); } return state; }, /** * APIMethod: nextTrigger * Restore the next state. If no items are in the next history * stack, this has no effect. The next history stack is populated * as states are restored from the previous history stack. * * Returns: * {Object} Item representing state that was restored. Undefined if no * items are in the next history stack. */ nextTrigger: function() { var state = this.nextStack.shift(); if(state != undefined) { this.previousStack.unshift(state); this.restoring = true; this.restore(state); this.restoring = false; this.onNextChange(this.nextStack[0], this.nextStack.length); this.onPreviousChange( this.previousStack[1], this.previousStack.length - 1 ); } return state; }, /** * APIMethod: clear * Clear history. */ clear: function() { this.previousStack = []; this.nextStack = []; }, /** * Method: restore * Update the state with the given object. * * Parameters: * state - {Object} An object representing the state to restore. */ restore: function(state) { var zoom = this.map.getZoomForResolution(state.resolution); this.map.setCenter(state.center, zoom); }, /** * Method: setListeners * Sets functions to be registered in the listeners object. */ setListeners: function() { this.listeners = {}; for(var type in this.registry) { this.listeners[type] = OpenLayers.Function.bind(function() { if(!this.restoring) { var state = this.registry[type].apply(this, arguments); this.previousStack.unshift(state); if(this.previousStack.length > 1) { this.onPreviousChange( this.previousStack[1], this.previousStack.length - 1 ); } if(this.previousStack.length > (this.limit + 1)) { this.previousStack.pop(); } if(this.nextStack.length > 0) { this.nextStack = []; this.onNextChange(null, 0); } } return true; }, this); } }, /** * APIMethod: activate * Activate the control. This registers any listeners. * * Returns: * {Boolean} Control successfully activated. */ activate: function() { var activated = false; if(this.map) { if(OpenLayers.Control.prototype.activate.apply(this)) { if(this.listeners == null) { this.setListeners(); } for(var type in this.listeners) { this.map.events.register(type, this, this.listeners[type]); } activated = true; if(this.previousStack.length == 0) { this.initStack(); } } } return activated; }, /** * Method: initStack * Called after the control is activated if the previous history stack is * empty. */ initStack: function() { if(this.map.getCenter()) { this.listeners.moveend(); } }, /** * APIMethod: deactivate * Deactivate the control. This unregisters any listeners. * * Returns: * {Boolean} Control successfully deactivated. */ deactivate: function() { var deactivated = false; if(this.map) { if(OpenLayers.Control.prototype.deactivate.apply(this)) { for(var type in this.listeners) { this.map.events.unregister( type, this, this.listeners[type] ); } if(this.clearOnDeactivate) { this.clear(); } deactivated = true; } } return deactivated; }, CLASS_NAME: "OpenLayers.Control.NavigationHistory" }); /* ====================================================================== OpenLayers/Control/PanZoom.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.PanZoom * * Inherits from: * - */ OpenLayers.Control.PanZoom = OpenLayers.Class(OpenLayers.Control, { /** * APIProperty: slideFactor * {Integer} Number of pixels by which we'll pan the map in any direction * on clicking the arrow buttons. */ slideFactor: 50, /** * Property: buttons * {Array(DOMElement)} Array of Button Divs */ buttons: null, /** * Property: position * {} */ position: null, /** * Constructor: OpenLayers.Control.PanZoom * * Parameters: * options - {Object} */ initialize: function(options) { this.position = new OpenLayers.Pixel(OpenLayers.Control.PanZoom.X, OpenLayers.Control.PanZoom.Y); OpenLayers.Control.prototype.initialize.apply(this, arguments); }, /** * APIMethod: destroy */ destroy: function() { OpenLayers.Control.prototype.destroy.apply(this, arguments); while(this.buttons.length) { var btn = this.buttons.shift(); btn.map = null; OpenLayers.Event.stopObservingElement(btn); } this.buttons = null; this.position = null; }, /** * Method: draw * * Parameters: * px - {} * * Returns: * {DOMElement} A reference to the container div for the PanZoom control. */ draw: function(px) { // initialize our internal div OpenLayers.Control.prototype.draw.apply(this, arguments); px = this.position; // place the controls this.buttons = []; var sz = new OpenLayers.Size(18,18); var centered = new OpenLayers.Pixel(px.x+sz.w/2, px.y); this._addButton("panup", "north-mini.png", centered, sz); px.y = centered.y+sz.h; this._addButton("panleft", "west-mini.png", px, sz); this._addButton("panright", "east-mini.png", px.add(sz.w, 0), sz); this._addButton("pandown", "south-mini.png", centered.add(0, sz.h*2), sz); this._addButton("zoomin", "zoom-plus-mini.png", centered.add(0, sz.h*3+5), sz); this._addButton("zoomworld", "zoom-world-mini.png", centered.add(0, sz.h*4+5), sz); this._addButton("zoomout", "zoom-minus-mini.png", centered.add(0, sz.h*5+5), sz); return this.div; }, /** * Method: _addButton * * Parameters: * id - {String} * img - {String} * xy - {} * sz - {} * * Returns: * {DOMElement} A Div (an alphaImageDiv, to be precise) that contains the * image of the button, and has all the proper event handlers set. */ _addButton:function(id, img, xy, sz) { var imgLocation = OpenLayers.Util.getImagesLocation() + img; var btn = OpenLayers.Util.createAlphaImageDiv( "OpenLayers_Control_PanZoom_" + id, xy, sz, imgLocation, "absolute"); //we want to add the outer div this.div.appendChild(btn); OpenLayers.Event.observe(btn, "mousedown", OpenLayers.Function.bindAsEventListener(this.buttonDown, btn)); OpenLayers.Event.observe(btn, "dblclick", OpenLayers.Function.bindAsEventListener(this.doubleClick, btn)); OpenLayers.Event.observe(btn, "click", OpenLayers.Function.bindAsEventListener(this.doubleClick, btn)); btn.action = id; btn.map = this.map; btn.slideFactor = this.slideFactor; //we want to remember/reference the outer div this.buttons.push(btn); return btn; }, /** * Method: doubleClick * * Parameters: * evt - {Event} * * Returns: * {Boolean} */ doubleClick: function (evt) { OpenLayers.Event.stop(evt); return false; }, /** * Method: buttonDown * * Parameters: * evt - {Event} */ buttonDown: function (evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } switch (this.action) { case "panup": this.map.pan(0, -this.slideFactor); break; case "pandown": this.map.pan(0, this.slideFactor); break; case "panleft": this.map.pan(-this.slideFactor, 0); break; case "panright": this.map.pan(this.slideFactor, 0); break; case "zoomin": this.map.zoomIn(); break; case "zoomout": this.map.zoomOut(); break; case "zoomworld": this.map.zoomToMaxExtent(); break; } OpenLayers.Event.stop(evt); }, CLASS_NAME: "OpenLayers.Control.PanZoom" }); /** * Constant: X * {Integer} */ OpenLayers.Control.PanZoom.X = 4; /** * Constant: Y * {Integer} */ OpenLayers.Control.PanZoom.Y = 4; /* ====================================================================== OpenLayers/Control/Panel.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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 * * Inherits from: * - */ OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, { /** * Property: controls * {Array()} */ controls: null, /** * APIProperty: defaultControl * The control which is activated when the control is * activated (turned on), which also happens at instantiation. */ defaultControl: null, /** * Constructor: OpenLayers.Control.Panel * Create a new control panel. * * 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 = []; }, /** * APIMethod: destroy */ destroy: function() { OpenLayers.Control.prototype.destroy.apply(this, arguments); for(var i = this.controls.length - 1 ; i >= 0; i--) { if(this.controls[i].events) { this.controls[i].events.un({ "activate": this.redraw, "deactivate": this.redraw, scope: this }); } OpenLayers.Event.stopObservingElement(this.controls[i].panel_div); this.controls[i].panel_div = null; } }, /** * APIMethod: activate */ activate: function() { if (OpenLayers.Control.prototype.activate.apply(this, arguments)) { for(var i = 0; i < this.controls.length; i++) { if (this.controls[i] == this.defaultControl) { this.controls[i].activate(); } } this.redraw(); return true; } else { return false; } }, /** * APIMethod: deactivate */ deactivate: function() { if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) { for(var i = 0; i < this.controls.length; i++) { this.controls[i].deactivate(); } return true; } else { return false; } }, /** * Method: draw * * Returns: * {DOMElement} */ draw: function() { OpenLayers.Control.prototype.draw.apply(this, arguments); for (var i = 0; i < this.controls.length; i++) { this.map.addControl(this.controls[i]); this.controls[i].deactivate(); this.controls[i].events.on({ "activate": this.redraw, "deactivate": this.redraw, scope: this }); } this.activate(); return this.div; }, /** * Method: redraw */ redraw: function() { this.div.innerHTML = ""; if (this.active) { for (var i = 0; i < this.controls.length; i++) { var element = this.controls[i].panel_div; if (this.controls[i].active) { element.className = this.controls[i].displayClass + "ItemActive"; } else { element.className = this.controls[i].displayClass + "ItemInactive"; } this.div.appendChild(element); } } }, /** * APIMethod: activateControl * * Parameters: * 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; } for (var i = 0; i < this.controls.length; i++) { if (this.controls[i] != control) { if (this.controls[i].type != OpenLayers.Control.TYPE_TOGGLE) { this.controls[i].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 - {} */ addControls: function(controls) { if (!(controls instanceof Array)) { 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; i < controls.length; i++) { var element = document.createElement("div"); var textNode = document.createTextNode(" "); 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, "mousedown", OpenLayers.Function.bindAsEventListener(OpenLayers.Event.stop)); } if (this.map) { // map.addControl() has already been called on the panel for (var i = 0; i < controls.length; i++) { this.map.addControl(controls[i]); controls[i].deactivate(); controls[i].events.on({ "activate": this.redraw, "deactivate": this.redraw, scope: this }); } this.redraw(); } }, /** * Method: onClick */ onClick: function (ctrl, evt) { OpenLayers.Event.stop(evt ? evt : window.event); this.activateControl(ctrl); }, /** * 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()} 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()} 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()} 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" }); /* ====================================================================== OpenLayers/Control/Permalink.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.Permalink * * Inherits from: * - */ OpenLayers.Control.Permalink = OpenLayers.Class(OpenLayers.Control, { /** * Property: element * {DOMElement} */ element: null, /** * APIProperty: base * {String} */ base: '', /** * APIProperty: displayProjection * {} Requires proj4js support. Projection used * when creating the coordinates in the link. This will reproject the * map coordinates into display coordinates. If you are using this * functionality, the permalink which is last added to the map will * determine the coordinate type which is read from the URL, which * means you should not add permalinks with different * displayProjections to the same map. */ displayProjection: null, /** * Constructor: OpenLayers.Control.Permalink * * Parameters: * element - {DOMElement} * base - {String} * options - {Object} options to the control. */ initialize: function(element, base, options) { OpenLayers.Control.prototype.initialize.apply(this, [options]); this.element = OpenLayers.Util.getElement(element); this.base = base || document.location.href; }, /** * APIMethod: destroy */ destroy: function() { if (this.element.parentNode == this.div) { this.div.removeChild(this.element); } this.element = null; this.map.events.unregister('moveend', this, this.updateLink); OpenLayers.Control.prototype.destroy.apply(this, arguments); }, /** * Method: setMap * Set the map property for the control. * * Parameters: * map - {} */ setMap: function(map) { OpenLayers.Control.prototype.setMap.apply(this, arguments); //make sure we have an arg parser attached for(var i=0; i< this.map.controls.length; i++) { var control = this.map.controls[i]; if (control.CLASS_NAME == "OpenLayers.Control.ArgParser") { // If a permalink is added to the map, and an ArgParser already // exists, we override the displayProjection to be the one // on the permalink. if (control.displayProjection != this.displayProjection) { this.displayProjection = control.displayProjection; } break; } } if (i == this.map.controls.length) { this.map.addControl(new OpenLayers.Control.ArgParser( { 'displayProjection': this.displayProjection })); } }, /** * Method: draw * * Returns: * {DOMElement} */ draw: function() { OpenLayers.Control.prototype.draw.apply(this, arguments); if (!this.element) { this.element = document.createElement("a"); this.element.innerHTML = OpenLayers.i18n("permalink"); this.element.href=""; this.div.appendChild(this.element); } this.map.events.on({ 'moveend': this.updateLink, 'changelayer': this.updateLink, 'changebaselayer': this.updateLink, scope: this }); return this.div; }, /** * Method: updateLink */ updateLink: function() { var center = this.map.getCenter(); // Map not initialized yet. Break out of this function. if (!center) { return; } var params = OpenLayers.Util.getParameters(this.base); params.zoom = this.map.getZoom(); var lat = center.lat; var lon = center.lon; if (this.displayProjection) { var mapPosition = OpenLayers.Projection.transform( { x: lon, y: lat }, this.map.getProjectionObject(), this.displayProjection ); lon = mapPosition.x; lat = mapPosition.y; } params.lat = Math.round(lat*100000)/100000; params.lon = Math.round(lon*100000)/100000; params.layers = ''; for(var i=0; i< this.map.layers.length; i++) { var layer = this.map.layers[i]; if (layer.isBaseLayer) { params.layers += (layer == this.map.baseLayer) ? "B" : "0"; } else { params.layers += (layer.getVisibility()) ? "T" : "F"; } } var href = this.base; if( href.indexOf('?') != -1 ){ href = href.substring( 0, href.indexOf('?') ); } href += '?' + OpenLayers.Util.getParameterString(params); this.element.href = href; }, CLASS_NAME: "OpenLayers.Control.Permalink" }); /* ====================================================================== OpenLayers/Control/Scale.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.Scale * Display a small scale indicator on the map. * Inherits from: * - */ OpenLayers.Control.Scale = OpenLayers.Class(OpenLayers.Control, { /** * Parameter: element * {DOMElement} */ element: null, /** * Constructor: OpenLayers.Control.Scale * * Parameters: * element - {DOMElement} * options - {Object} */ initialize: function(element, options) { OpenLayers.Control.prototype.initialize.apply(this, [options]); this.element = OpenLayers.Util.getElement(element); }, /** * Method: draw * * Returns: * {DOMElement} */ draw: function() { OpenLayers.Control.prototype.draw.apply(this, arguments); if (!this.element) { this.element = document.createElement("div"); this.div.appendChild(this.element); } this.map.events.register( 'moveend', this, this.updateScale); this.updateScale(); return this.div; }, /** * Method: updateScale */ updateScale: function() { var scale = this.map.getScale(); if (!scale) { return; } if (scale >= 9500 && scale <= 950000) { scale = Math.round(scale / 1000) + "K"; } else if (scale >= 950000) { scale = Math.round(scale / 1000000) + "M"; } else { scale = Math.round(scale); } this.element.innerHTML = OpenLayers.i18n("scale", {'scaleDenom':scale}); }, CLASS_NAME: "OpenLayers.Control.Scale" }); /* ====================================================================== OpenLayers/Control/ScaleLine.js ====================================================================== */ /* Copyright (c) 2006-2007 MetaCarta, Inc., published under a modified BSD license. * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt * for the full text of the license. */ /** * @requires OpenLayers/Control.js */ /** * Class: OpenLayers.Control.ScaleLine * Display a small line indicator representing the current map scale on the map. * * Inherits from: * - * * Is a very close copy of: * - */ OpenLayers.Control.ScaleLine = OpenLayers.Class(OpenLayers.Control, { /** * Property: maxWidth * {Integer} Maximum width of the scale line in pixels. Default is 100. */ maxWidth: 100, /** * Property: topOutUnits * {String} Units for zoomed out on top bar. Default is km. */ topOutUnits: "km", /** * Property: topInUnits * {String} Units for zoomed in on top bar. Default is m. */ topInUnits: "m", /** * Property: bottomOutUnits * {String} Units for zoomed out on bottom bar. Default is mi. */ bottomOutUnits: "mi", /** * Property: bottomInUnits * {String} Units for zoomed in on bottom bar. Default is ft. */ bottomInUnits: "ft", /** * Property: eTop * {DOMElement} */ eTop: null, /** * Property: eBottom * {DOMElement} */ eBottom:null, /** * Constructor: OpenLayers.ScaleLine * Create a new scale line control. * * 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]); }, /** * Method: draw * * Returns: * {DOMElement} */ draw: function() { OpenLayers.Control.prototype.draw.apply(this, arguments); if (!this.eTop) { this.div.style.display = "block"; this.div.style.position = "absolute"; // stick in the top bar this.eTop = document.createElement("div"); this.eTop.className = this.displayClass + "Top"; var theLen = this.topInUnits.length; this.div.appendChild(this.eTop); if((this.topOutUnits == "") || (this.topInUnits == "")) { this.eTop.style.visibility = "hidden"; } else { this.eTop.style.visibility = "visible"; } // and the bottom bar this.eBottom = document.createElement("div"); this.eBottom.className = this.displayClass + "Bottom"; this.div.appendChild(this.eBottom); if((this.bottomOutUnits == "") || (this.bottomInUnits == "")) { this.eBottom.style.visibility = "hidden"; } else { this.eBottom.style.visibility = "visible"; } } this.map.events.register('moveend', this, this.update); this.update(); return this.div; }, /** * Method: getBarLen * Given a number, round it down to the nearest 1,2,5 times a power of 10. * That seems a fairly useful set of number groups to use. * * Parameters: * maxLen - {float} the number we're rounding down from * * Returns: * {Float} the rounded number (less than or equal to maxLen) */ getBarLen: function(maxLen) { // nearest power of 10 lower than maxLen var digits = parseInt(Math.log(maxLen) / Math.log(10)); var pow10 = Math.pow(10, digits); // ok, find first character var firstChar = parseInt(maxLen / pow10); // right, put it into the correct bracket var barLen; if(firstChar > 5) { barLen = 5; } else if(firstChar > 2) { barLen = 2; } else { barLen = 1; } // scale it up the correct power of 10 return barLen * pow10; }, /** * Method: update * Update the size of the bars, and the labels they contain. */ update: function() { var res = this.map.getResolution(); if (!res) { return; } var curMapUnits = this.map.units; var inches = OpenLayers.INCHES_PER_UNIT; // convert maxWidth to map units var maxSizeData = this.maxWidth * res * inches[curMapUnits]; // decide whether to use large or small scale units var topUnits; var bottomUnits; if(maxSizeData > 100000) { topUnits = this.topOutUnits; bottomUnits = this.bottomOutUnits; } else { topUnits = this.topInUnits; bottomUnits = this.bottomInUnits; } // and to map units units var topMax = maxSizeData / inches[topUnits]; var bottomMax = maxSizeData / inches[bottomUnits]; // now trim this down to useful block length var topRounded = this.getBarLen(topMax); var bottomRounded = this.getBarLen(bottomMax); // and back to display units topMax = topRounded / inches[curMapUnits] * inches[topUnits]; bottomMax = bottomRounded / inches[curMapUnits] * inches[bottomUnits]; // and to pixel units var topPx = topMax / res; var bottomPx = bottomMax / res; // now set the pixel widths this.eTop.style.width = Math.round(topPx) + "px"; this.eBottom.style.width = Math.round(bottomPx) + "px"; // and the values inside them this.eTop.innerHTML = topRounded + " " + topUnits; this.eBottom.innerHTML = bottomRounded + " " + bottomUnits ; }, CLASS_NAME: "OpenLayers.Control.ScaleLine" }); /* ====================================================================== OpenLayers/Control/ZoomToMaxExtent.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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.ZoomToMaxExtent * Imlements a very simple button control. Designed to be used with a * . * * Inherits from: * - */ OpenLayers.Control.ZoomToMaxExtent = OpenLayers.Class(OpenLayers.Control, { /** * Property: type * TYPE_BUTTON. */ type: OpenLayers.Control.TYPE_BUTTON, /* * Method: trigger * Do the zoom. */ trigger: function() { if (this.map) { this.map.zoomToMaxExtent(); } }, CLASS_NAME: "OpenLayers.Control.ZoomToMaxExtent" }); /* ====================================================================== OpenLayers/Events.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Util.js */ /** * Namespace: OpenLayers.Event * Utility functions for event handling. */ OpenLayers.Event = { /** * Property: observers * {Object} A hashtable cache of the event observers. Keyed by * element._eventCacheID */ observers: false, /** * Constant: KEY_BACKSPACE * {int} */ KEY_BACKSPACE: 8, /** * Constant: KEY_TAB * {int} */ KEY_TAB: 9, /** * Constant: KEY_RETURN * {int} */ KEY_RETURN: 13, /** * Constant: KEY_ESC * {int} */ KEY_ESC: 27, /** * Constant: KEY_LEFT * {int} */ KEY_LEFT: 37, /** * Constant: KEY_UP * {int} */ KEY_UP: 38, /** * Constant: KEY_RIGHT * {int} */ KEY_RIGHT: 39, /** * Constant: KEY_DOWN * {int} */ KEY_DOWN: 40, /** * Constant: KEY_DELETE * {int} */ KEY_DELETE: 46, /** * Method: element * Cross browser event element detection. * * Parameters: * event - {Event} * * Returns: * {DOMElement} The element that caused the event */ element: function(event) { return event.target || event.srcElement; }, /** * Method: isLeftClick * Determine whether event was caused by a left click. * * Parameters: * event - {Event} * * Returns: * {Boolean} */ isLeftClick: function(event) { return (((event.which) && (event.which == 1)) || ((event.button) && (event.button == 1))); }, /** * Method: stop * Stops an event from propagating. * * Parameters: * event - {Event} * allowDefault - {Boolean} If true, we stop the event chain but * still allow the default browser * behaviour (text selection, radio-button * clicking, etc) * Default false */ stop: function(event, allowDefault) { if (!allowDefault) { if (event.preventDefault) { event.preventDefault(); } else { event.returnValue = false; } } if (event.stopPropagation) { event.stopPropagation(); } else { event.cancelBubble = true; } }, /** * Method: findElement * * Parameters: * event - {Event} * tagName - {String} * * Returns: * {DOMElement} The first node with the given tagName, starting from the * node the event was triggered on and traversing the DOM upwards */ findElement: function(event, tagName) { var element = OpenLayers.Event.element(event); while (element.parentNode && (!element.tagName || (element.tagName.toUpperCase() != tagName.toUpperCase()))){ element = element.parentNode; } return element; }, /** * Method: observe * * Parameters: * elementParam - {DOMElement || String} * name - {String} * observer - {function} * useCapture - {Boolean} */ observe: function(elementParam, name, observer, useCapture) { var element = OpenLayers.Util.getElement(elementParam); useCapture = useCapture || false; if (name == 'keypress' && (navigator.appVersion.match(/Konqueror|Safari|KHTML/) || element.attachEvent)) { name = 'keydown'; } //if observers cache has not yet been created, create it if (!this.observers) { this.observers = {}; } //if not already assigned, make a new unique cache ID if (!element._eventCacheID) { var idPrefix = "eventCacheID_"; if (element.id) { idPrefix = element.id + "_" + idPrefix; } element._eventCacheID = OpenLayers.Util.createUniqueID(idPrefix); } var cacheID = element._eventCacheID; //if there is not yet a hash entry for this element, add one if (!this.observers[cacheID]) { this.observers[cacheID] = []; } //add a new observer to this element's list this.observers[cacheID].push({ 'element': element, 'name': name, 'observer': observer, 'useCapture': useCapture }); //add the actual browser event listener if (element.addEventListener) { element.addEventListener(name, observer, useCapture); } else if (element.attachEvent) { element.attachEvent('on' + name, observer); } }, /** * Method: stopObservingElement * Given the id of an element to stop observing, cycle through the * element's cached observers, calling stopObserving on each one, * skipping those entries which can no longer be removed. * * parameters: * elementParam - {DOMElement || String} */ stopObservingElement: function(elementParam) { var element = OpenLayers.Util.getElement(elementParam); var cacheID = element._eventCacheID; this._removeElementObservers(OpenLayers.Event.observers[cacheID]); }, /** * Method: _removeElementObservers * * Parameters: * elementObservers - {Array(Object)} Array of (element, name, * observer, usecapture) objects, * taken directly from hashtable */ _removeElementObservers: function(elementObservers) { if (elementObservers) { for(var i = elementObservers.length-1; i >= 0; i--) { var entry = elementObservers[i]; var args = new Array(entry.element, entry.name, entry.observer, entry.useCapture); var removed = OpenLayers.Event.stopObserving.apply(this, args); } } }, /** * Method: stopObserving * * Parameters: * elementParam - {DOMElement || String} * name - {String} * observer - {function} * useCapture - {Boolean} * * Returns: * {Boolean} Whether or not the event observer was removed */ stopObserving: function(elementParam, name, observer, useCapture) { useCapture = useCapture || false; var element = OpenLayers.Util.getElement(elementParam); var cacheID = element._eventCacheID; if (name == 'keypress') { if ( navigator.appVersion.match(/Konqueror|Safari|KHTML/) || element.detachEvent) { name = 'keydown'; } } // find element's entry in this.observers cache and remove it var foundEntry = false; var elementObservers = OpenLayers.Event.observers[cacheID]; if (elementObservers) { // find the specific event type in the element's list var i=0; while(!foundEntry && i < elementObservers.length) { var cacheEntry = elementObservers[i]; if ((cacheEntry.name == name) && (cacheEntry.observer == observer) && (cacheEntry.useCapture == useCapture)) { elementObservers.splice(i, 1); if (elementObservers.length == 0) { delete OpenLayers.Event.observers[cacheID]; } foundEntry = true; break; } i++; } } //actually remove the event listener from browser if (foundEntry) { if (element.removeEventListener) { element.removeEventListener(name, observer, useCapture); } else if (element && element.detachEvent) { element.detachEvent('on' + name, observer); } } return foundEntry; }, /** * Method: unloadCache * Cycle through all the element entries in the events cache and call * stopObservingElement on each. */ unloadCache: function() { // check for OpenLayers.Event before checking for observers, because // OpenLayers.Event may be undefined in IE if no map instance was // created if (OpenLayers.Event && OpenLayers.Event.observers) { for (var cacheID in OpenLayers.Event.observers) { var elementObservers = OpenLayers.Event.observers[cacheID]; OpenLayers.Event._removeElementObservers.apply(this, [elementObservers]); } OpenLayers.Event.observers = false; } }, CLASS_NAME: "OpenLayers.Event" }; /* prevent memory leaks in IE */ OpenLayers.Event.observe(window, 'unload', OpenLayers.Event.unloadCache, false); // FIXME: Remove this in 3.0. In 3.0, Event.stop will no longer be provided // by OpenLayers. if (window.Event) { OpenLayers.Util.applyDefaults(window.Event, OpenLayers.Event); } else { var Event = OpenLayers.Event; } /** * Class: OpenLayers.Events */ OpenLayers.Events = OpenLayers.Class({ /** * Constant: BROWSER_EVENTS * {Array(String)} supported events */ BROWSER_EVENTS: [ "mouseover", "mouseout", "mousedown", "mouseup", "mousemove", "click", "dblclick", "resize", "focus", "blur" ], /** * Property: listeners * {Object} Hashtable of Array(Function): events listener functions */ listeners: null, /** * Property: object * {Object} the code object issuing application events */ object: null, /** * Property: element * {DOMElement} the DOM element receiving browser events */ element: null, /** * Property: eventTypes * {Array(String)} list of support application events */ eventTypes: null, /** * Property: eventHandler * {Function} bound event handler attached to elements */ eventHandler: null, /** * APIProperty: fallThrough * {Boolean} */ fallThrough: null, /** * Constructor: OpenLayers.Events * Construct an OpenLayers.Events object. * * Parameters: * object - {Object} The js object to which this Events object is being * added element - {DOMElement} A dom element to respond to browser events * eventTypes - {Array(String)} Array of custom application events * fallThrough - {Boolean} Allow events to fall through after these have * been handled? */ initialize: function (object, element, eventTypes, fallThrough) { this.object = object; this.element = element; this.eventTypes = eventTypes; this.fallThrough = fallThrough; this.listeners = {}; // keep a bound copy of handleBrowserEvent() so that we can // pass the same function to both Event.observe() and .stopObserving() this.eventHandler = OpenLayers.Function.bindAsEventListener( this.handleBrowserEvent, this ); // if eventTypes is specified, create a listeners list for each // custom application event. if (this.eventTypes != null) { for (var i = 0; i < this.eventTypes.length; i++) { this.addEventType(this.eventTypes[i]); } } // if a dom element is specified, add a listeners list // for browser events on the element and register them if (this.element != null) { this.attachToElement(element); } }, /** * APIMethod: destroy */ destroy: function () { if (this.element) { OpenLayers.Event.stopObservingElement(this.element); } this.element = null; this.listeners = null; this.object = null; this.eventTypes = null; this.fallThrough = null; this.eventHandler = null; }, /** * APIMethod: addEventType * Add a new event type to this events object. * If the event type has already been added, do nothing. * * Parameters: * eventName - {String} */ addEventType: function(eventName) { if (!this.listeners[eventName]) { this.listeners[eventName] = []; } }, /** * Method: attachToElement * * Parameters: * element - {HTMLDOMElement} a DOM element to attach browser events to */ attachToElement: function (element) { for (var i = 0; i < this.BROWSER_EVENTS.length; i++) { var eventType = this.BROWSER_EVENTS[i]; // every browser event has a corresponding application event // (whether it's listened for or not). this.addEventType(eventType); // use Prototype to register the event cross-browser OpenLayers.Event.observe(element, eventType, this.eventHandler); } // disable dragstart in IE so that mousedown/move/up works normally OpenLayers.Event.observe(element, "dragstart", OpenLayers.Event.stop); }, /** * Method: on * Convenience method for registering listeners with a common scope. * * Example use: * (code) * events.on({ * "loadstart": loadStartListener, * "loadend": loadEndListener, * scope: object * }); * (end) */ on: function(object) { for(var type in object) { if(type != "scope") { this.register(type, object.scope, object[type]); } } }, /** * APIMethod: register * Register an event on the events object. * * When the event is triggered, the 'func' function will be called, in the * context of 'obj'. Imagine we were to register an event, specifying an * OpenLayers.Bounds Object as 'obj'. When the event is triggered, the * context in the callback function will be our Bounds object. This means * that within our callback function, we can access the properties and * methods of the Bounds object through the "this" variable. So our * callback could execute something like: * : leftStr = "Left: " + this.left; * * or * * : centerStr = "Center: " + this.getCenterLonLat(); * * Parameters: * type - {String} Name of the event to register * obj - {Object} The object to bind the context to for the callback#. * If no object is specified, default is the Events's * 'object' property. * func - {Function} The callback function. If no callback is * specified, this function does nothing. * * */ register: function (type, obj, func) { if (func != null && ((this.eventTypes && OpenLayers.Util.indexOf(this.eventTypes, type) != -1) || OpenLayers.Util.indexOf(this.BROWSER_EVENTS, type) != -1)) { if (obj == null) { obj = this.object; } var listeners = this.listeners[type]; if (listeners != null) { listeners.push( {obj: obj, func: func} ); } } }, /** * APIMethod: registerPriority * Same as register() but adds the new listener to the *front* of the * events queue instead of to the end. * * TODO: get rid of this in 3.0 - Decide whether listeners should be * called in the order they were registered or in reverse order. * * * Parameters: * type - {String} Name of the event to register * obj - {Object} The object to bind the context to for the callback#. * If no object is specified, default is the Events's * 'object' property. * func - {Function} The callback function. If no callback is * specified, this function does nothing. */ registerPriority: function (type, obj, func) { if (func != null) { if (obj == null) { obj = this.object; } var listeners = this.listeners[type]; if (listeners != null) { listeners.unshift( {obj: obj, func: func} ); } } }, /** * Method: un * Convenience method for unregistering listeners with a common scope. * * Example use: * (code) * events.un({ * "loadstart": loadStartListener, * "loadend": loadEndListener, * scope: object * }); * (end) */ un: function(object) { for(var type in object) { if(type != "scope") { this.unregister(type, object.scope, object[type]); } } }, /** * APIMethod: unregister * * Parameters: * type - {String} * obj - {Object} If none specified, defaults to this.object * func - {Function} */ unregister: function (type, obj, func) { if (obj == null) { obj = this.object; } var listeners = this.listeners[type]; if (listeners != null) { for (var i = 0; i < listeners.length; i++) { if (listeners[i].obj == obj && listeners[i].func == func) { listeners.splice(i, 1); break; } } } }, /** * Method: remove * Remove all listeners for a given event type. If type is not registered, * does nothing. * * Parameters: * type - {String} */ remove: function(type) { if (this.listeners[type] != null) { this.listeners[type] = []; } }, /** * APIMethod: triggerEvent * Trigger a specified registered event. * * Parameters: * type - {String} * evt - {Event} * * Returns: * {Boolean} The last listener return. If a listener returns false, the * chain of listeners will stop getting called. */ triggerEvent: function (type, evt) { // prep evt object with object & div references if (evt == null) { evt = {}; } evt.object = this.object; evt.element = this.element; if(!evt.type) { evt.type = type; } // execute all callbacks registered for specified type // get a clone of the listeners array to // allow for splicing during callbacks var listeners = (this.listeners[type]) ? this.listeners[type].slice() : null; if ((listeners != null) && (listeners.length > 0)) { var continueChain; for (var i = 0; i < listeners.length; i++) { var callback = listeners[i]; // bind the context to callback.obj continueChain = callback.func.apply(callback.obj, [evt]); if ((continueChain != undefined) && (continueChain == false)) { // if callback returns false, execute no more callbacks. break; } } // don't fall through to other DOM elements if (!this.fallThrough) { OpenLayers.Event.stop(evt, true); } } return continueChain; }, /** * Method: handleBrowserEvent * Basically just a wrapper to the triggerEvent() function, but takes * care to set a property 'xy' on the event with the current mouse * position. * * Parameters: * evt - {Event} */ handleBrowserEvent: function (evt) { evt.xy = this.getMousePosition(evt); this.triggerEvent(evt.type, evt); }, /** * Method: getMousePosition * * Parameters: * evt - {Event} * * Returns: * {} The current xy coordinate of the mouse, adjusted * for offsets */ getMousePosition: function (evt) { if (!this.element.offsets) { this.element.offsets = OpenLayers.Util.pagePosition(this.element); this.element.offsets[0] += (document.documentElement.scrollLeft || document.body.scrollLeft); this.element.offsets[1] += (document.documentElement.scrollTop || document.body.scrollTop); } return new OpenLayers.Pixel( (evt.clientX + (document.documentElement.scrollLeft || document.body.scrollLeft)) - this.element.offsets[0] - (document.documentElement.clientLeft || 0), (evt.clientY + (document.documentElement.scrollTop || document.body.scrollTop)) - this.element.offsets[1] - (document.documentElement.clientTop || 0) ); }, CLASS_NAME: "OpenLayers.Events" }); /* ====================================================================== OpenLayers/Format.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Util.js */ /** * Class: OpenLayers.Format * Base class for format reading/writing a variety of formats. Subclasses * of OpenLayers.Format are expected to have read and write methods. */ OpenLayers.Format = OpenLayers.Class({ /** * APIProperty: externalProjection * {} When passed a externalProjection and * internalProjection, the format will reproject the geometries it * reads or writes. The externalProjection is the projection used by * the content which is passed into read or which comes out of write. * In order to reproject, a projection transformation function for the * specified projections must be available. This support may be * provided via proj4js or via a custom transformation function. See * {} for more information on * custom transformations. */ externalProjection: null, /** * APIProperty: internalProjection * {} When passed a externalProjection and * internalProjection, the format will reproject the geometries it * reads or writes. The internalProjection is the projection used by * the geometries which are returned by read or which are passed into * write. In order to reproject, a projection transformation function * for the specified projections must be available. This support may be * provided via proj4js or via a custom transformation function. See * {} for more information on * custom transformations. */ internalProjection: null, /** * Constructor: OpenLayers.Format * Instances of this class are not useful. See one of the subclasses. * * Parameters: * options - {Object} An optional object with properties to set on the * format * * Returns: * An instance of OpenLayers.Format */ initialize: function(options) { OpenLayers.Util.extend(this, options); }, /** * Method: read * Read data from a string, and return an object whose type depends on the * subclass. * * Parameters: * data - {string} Data to read/parse. * * Returns: * Depends on the subclass */ read: function(data) { alert(OpenLayers.i18n("readNotImplemented")); }, /** * Method: write * Accept an object, and return a string. * * Parameters: * object - {Object} Object to be serialized * * Returns: * {String} A string representation of the object. */ write: function(object) { alert(OpenLayers.i18n("writeNotImplemented")); }, CLASS_NAME: "OpenLayers.Format" }); /* ====================================================================== OpenLayers/Lang/en.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Lang.js */ /** * Namespace: OpenLayers.Lang["en"] * Dictionary for English. Keys for entries are used in calls to * . Entry bodies are normal strings or * strings formatted for use with calls. */ OpenLayers.Lang.en = { 'unhandledRequest': "Unhandled request return ${statusText}", 'permalink': "Permalink", 'overlays': "Overlays", 'baseLayer': "Base Layer", 'sameProjection': "The overview map only works when it is in the same projection as the main map", 'readNotImplemented': "Read not implemented.", 'writeNotImplemented': "Write not implemented.", 'noFID': "Can't update a feature for which there is no FID.", 'errorLoadingGML': "Error in loading GML file ${url}", 'browserNotSupported': "Your browser does not support vector rendering. Currently supported renderers are:\n${renderers}", 'componentShouldBe': "addFeatures : component should be an ${geomType}", // console message 'getFeatureError': "getFeatureFromEvent called on layer with no renderer. This usually means you " + "destroyed a layer, but not some handler which is associated with it.", // console message 'minZoomLevelError': "The minZoomLevel property is only intended for use " + "with the FixedZoomLevels-descendent layers. That this " + "wfs layer checks for minZoomLevel is a relic of the" + "past. We cannot, however, remove it without possibly " + "breaking OL based applications that may depend on it." + " Therefore we are deprecating it -- the minZoomLevel " + "check below will be removed at 3.0. Please instead " + "use min/max resolution setting as described here: " + "http://trac.openlayers.org/wiki/SettingZoomLevels", 'commitSuccess': "WFS Transaction: SUCCESS ${response}", 'commitFailed': "WFS Transaction: FAILED ${response}", 'googleWarning': "The Google Layer was unable to load correctly.

" + "To get rid of this message, select a new BaseLayer " + "in the layer switcher in the upper-right corner.

" + "Most likely, this is because the Google Maps library " + "script was either not included, or does not contain the " + "correct API key for your site.

" + "Developers: For help getting this working correctly, " + "click here", 'getLayerWarning': "The ${layerType} Layer was unable to load correctly.

" + "To get rid of this message, select a new BaseLayer " + "in the layer switcher in the upper-right corner.

" + "Most likely, this is because the ${layerLib} library " + "script was either not correctly included.

" + "Developers: For help getting this working correctly, " + "click here", 'scale': "Scale = 1 : ${scaleDenom}", // console message 'layerAlreadyAdded': "You tried to add the layer: ${layerName} to the map, but it has already been added", // console message 'reprojectDeprecated': "You are using the 'reproject' option " + "on the ${layerName} layer. This option is deprecated: " + "its use was designed to support displaying data over commercial " + "basemaps, but that functionality should now be achieved by using " + "Spherical Mercator support. More information is available from " + "http://trac.openlayers.org/wiki/SphericalMercator.", // console message 'methodDeprecated': "This method has been deprecated and will be removed in 3.0. " + "Please use ${newMethod} instead.", // console message 'boundsAddError': "You must pass both x and y values to the add function.", // console message 'lonlatAddError': "You must pass both lon and lat values to the add function.", // console message 'pixelAddError': "You must pass both x and y values to the add function.", // console message 'unsupportedGeometryType': "Unsupported geometry type: ${geomType}", // console message 'pagePositionFailed': "OpenLayers.Util.pagePosition failed: element with id ${elemId} may be misplaced.", 'end': '' }; /* ====================================================================== OpenLayers/Popup/Anchored.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Popup.js */ /** * Class: OpenLayers.Popup.Anchored * * Inherits from: * - */ OpenLayers.Popup.Anchored = OpenLayers.Class(OpenLayers.Popup, { /** * Parameter: relativePosition * {String} Relative position of the popup ("lr", "ll", "tr", or "tl"). */ relativePosition: null, /** * Parameter: anchor * {Object} Object to which we'll anchor the popup. Must expose a * 'size' () and 'offset' (). */ anchor: null, /** * Constructor: OpenLayers.Popup.Anchored * * Parameters: * id - {String} * lonlat - {} * size - {} * contentHTML - {String} * anchor - {Object} Object which must expose a 'size' * and 'offset' (generally an ). * closeBox - {Boolean} * closeBoxCallback - {Function} Function to be called on closeBox click. */ initialize:function(id, lonlat, size, contentHTML, anchor, closeBox, closeBoxCallback) { var newArguments = new Array(id, lonlat, size, contentHTML, closeBox, closeBoxCallback); OpenLayers.Popup.prototype.initialize.apply(this, newArguments); this.anchor = (anchor != null) ? anchor : { size: new OpenLayers.Size(0,0), offset: new OpenLayers.Pixel(0,0)}; }, /** * APIMethod: destroy */ destroy: function() { this.anchor = null; this.relativePosition = null; OpenLayers.Popup.prototype.destroy.apply(this, arguments); }, /** * APIMethod: show * Overridden from Popup since user might hide popup and then show() it * in a new location (meaning we might want to update the relative * position on the show) */ show: function() { this.updatePosition(); OpenLayers.Popup.prototype.show.apply(this, arguments); }, /** * Method: moveTo * Since the popup is moving to a new px, it might need also to be moved * relative to where the marker is. We first calculate the new * relativePosition, and then we calculate the new px where we will * put the popup, based on the new relative position. * * If the relativePosition has changed, we must also call * updateRelativePosition() to make any visual changes to the popup * which are associated with putting it in a new relativePosition. * * Parameters: * px - {} */ moveTo: function(px) { var oldRelativePosition = this.relativePosition; this.relativePosition = this.calculateRelativePosition(px); var newPx = this.calculateNewPx(px); var newArguments = new Array(newPx); OpenLayers.Popup.prototype.moveTo.apply(this, newArguments); //if this move has caused the popup to change its relative position, // we need to make the appropriate cosmetic changes. if (this.relativePosition != oldRelativePosition) { this.updateRelativePosition(); } }, /** * APIMethod: setSize * * Parameters: * size - {} */ setSize:function(size) { OpenLayers.Popup.prototype.setSize.apply(this, arguments); if ((this.lonlat) && (this.map)) { var px = this.map.getLayerPxFromLonLat(this.lonlat); this.moveTo(px); } }, /** * Method: calculateRelativePosition * * Parameters: * px - {} * * Returns: * {String} The relative position ("br" "tr" "tl "bl") at which the popup * should be placed. */ calculateRelativePosition:function(px) { var lonlat = this.map.getLonLatFromLayerPx(px); var extent = this.map.getExtent(); var quadrant = extent.determineQuadrant(lonlat); return OpenLayers.Bounds.oppositeQuadrant(quadrant); }, /** * Method: updateRelativePosition * The popup has been moved to a new relative location, so we may want to * make some cosmetic adjustments to it. * * Note that in the classic Anchored popup, there is nothing to do * here, since the popup looks exactly the same in all four positions. * Subclasses such as the AnchoredBubble and Framed, however, will * want to do something special here. */ updateRelativePosition: function() { //to be overridden by subclasses }, /** * Method: calculateNewPx * * Parameters: * px - {} * * Returns: * {} The the new px position of the popup on the screen * relative to the passed-in px. */ calculateNewPx:function(px) { var newPx = px.offset(this.anchor.offset); var top = (this.relativePosition.charAt(0) == 't'); newPx.y += (top) ? -this.size.h : this.anchor.size.h; var left = (this.relativePosition.charAt(1) == 'l'); newPx.x += (left) ? -this.size.w : this.anchor.size.w; return newPx; }, CLASS_NAME: "OpenLayers.Popup.Anchored" }); /* ====================================================================== OpenLayers/Projection.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under a modified BSD license. * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt * for the full text of the license. */ /** * @requires OpenLayers/Util.js */ /** * Class: OpenLayers.Projection * Class for coordinate transforms between coordinate systems. * Depends on the proj4js library. If proj4js is not available, * then this is just an empty stub. */ OpenLayers.Projection = OpenLayers.Class({ /** * Property: proj * {Object} Proj4js.Proj instance. */ proj: null, /** * Property: projCode * {String} */ projCode: null, /** * Constructor: OpenLayers.Projection * This class offers several methods for interacting with a wrapped * pro4js projection object. * * Parameters: * options - {Object} An optional object with properties to set on the * format * * Returns: * {} A projection object. */ initialize: function(projCode, options) { OpenLayers.Util.extend(this, options); this.projCode = projCode; if (window.Proj4js) { this.proj = new Proj4js.Proj(projCode); } }, /** * APIMethod: getCode * Get the string SRS code. * * Returns: * {String} The SRS code. */ getCode: function() { return this.proj ? this.proj.srsCode : this.projCode; }, /** * APIMethod: getUnits * Get the units string for the projection -- returns null if * proj4js is not available. * * Returns: * {String} The units abbreviation. */ getUnits: function() { return this.proj ? this.proj.units : null; }, /** * Method: toString * Convert projection to string (getCode wrapper). * * Returns: * {String} The projection code. */ toString: function() { return this.getCode(); }, /** * Method: equals * Test equality of two projection instances. Determines equality based * soley on the projection code. * * Returns: * {Boolean} The two projections are equivalent. */ equals: function(projection) { if (projection && projection.getCode) { return this.getCode() == projection.getCode(); } else { return false; } }, /* Method: destroy * Destroy projection object. */ destroy: function() { delete this.proj; delete this.projCode; }, CLASS_NAME: "OpenLayers.Projection" }); /** * Property: transforms * Transforms is an object, with from properties, each of which may * have a to property. This allows you to define projections without * requiring support for proj4js to be included. * * This object has keys which correspond to a 'source' projection object. The * keys should be strings, corresponding to the projection.getCode() value. * Each source projection object should have a set of destination projection * keys included in the object. * * Each value in the destination object should be a transformation function, * where the function is expected to be passed an object with a .x and a .y * property. The function should return the object, with the .x and .y * transformed according to the transformation function. * * Note - Properties on this object should not be set directly. To add a * transform method to this object, use the method. For an * example of usage, see the OpenLayers.Layer.SphericalMercator file. */ OpenLayers.Projection.transforms = {}; /** * APIMethod: addTransform * Set a custom transform method between two projections. Use this method in * cases where the proj4js lib is not available or where custom projections * need to be handled. * * Parameters: * from - {String} The code for the source projection * to - {String} the code for the destination projection * method - {Function} A function that takes a point as an argument and * transforms that point from the source to the destination projection * in place. The original point should be modified. */ OpenLayers.Projection.addTransform = function(from, to, method) { if(!OpenLayers.Projection.transforms[from]) { OpenLayers.Projection.transforms[from] = {}; } OpenLayers.Projection.transforms[from][to] = method; }; /** * APIMethod: transform * Transform a point coordinate from one projection to another. Note that * the input point is transformed in place. * * Parameters: * point - {{OpenLayers.Geometry.Point> | Object} An object with x and y * properties representing coordinates in those dimensions. * sourceProj - {OpenLayers.Projection} Source map coordinate system * destProj - {OpenLayers.Projection} Destination map coordinate system * * Returns: * point - {object} A transformed coordinate. The original point is modified. */ OpenLayers.Projection.transform = function(point, source, dest) { if (source.proj && dest.proj) { point = Proj4js.transform(source.proj, dest.proj, point); } else if (source && dest && OpenLayers.Projection.transforms[source.getCode()] && OpenLayers.Projection.transforms[source.getCode()][dest.getCode()]) { OpenLayers.Projection.transforms[source.getCode()][dest.getCode()](point); } return point; }; /* ====================================================================== OpenLayers/Renderer/Elements.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Renderer.js */ /** * Class: OpenLayers.Renderer.Elements * This is another virtual class in that it should never be instantiated by * itself as a Renderer. It exists because there is *tons* of shared * functionality between different vector libraries which use nodes/elements * as a base for rendering vectors. * * The highlevel bits of code that are implemented here are the adding and * removing of geometries, which is essentially the same for any * element-based renderer. The details of creating each node and drawing the * paths are of course different, but the machinery is the same. * * Inherits: * - */ OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, { /** * Property: rendererRoot * {DOMElement} */ rendererRoot: null, /** * Property: root * {DOMElement} */ root: null, /** * Property: xmlns * {String} */ xmlns: null, /** * Property: minimumSymbolizer * {Object} */ minimumSymbolizer: { strokeLinecap: "round", strokeOpacity: 1, fillOpacity: 1, pointRadius: 0 }, /** * Constructor: OpenLayers.Renderer.Elements * * Parameters: * containerID - {String} */ initialize: function(containerID) { OpenLayers.Renderer.prototype.initialize.apply(this, arguments); this.rendererRoot = this.createRenderRoot(); this.root = this.createRoot(); this.rendererRoot.appendChild(this.root); this.container.appendChild(this.rendererRoot); }, /** * Method: destroy */ destroy: function() { this.clear(); this.rendererRoot = null; this.root = null; this.xmlns = null; OpenLayers.Renderer.prototype.destroy.apply(this, arguments); }, /** * Method: clear * Remove all the elements from the root */ clear: function() { if (this.root) { while (this.root.childNodes.length > 0) { this.root.removeChild(this.root.firstChild); } } }, /** * Method: getNodeType * This function is in charge of asking the specific renderer which type * of node to create for the given geometry and style. All geometries * in an Elements-based renderer consist of one node and some * attributes. We have the nodeFactory() function which creates a node * for us, but it takes a 'type' as input, and that is precisely what * this function tells us. * * Parameters: * geometry - {} * style - {Object} * * Returns: * {String} The corresponding node type for the specified geometry */ getNodeType: function(geometry, style) { }, /** * Method: drawGeometry * Draw the geometry, creating new nodes, setting paths, setting style, * setting featureId on the node. This method should only be called * by the renderer itself. * * Parameters: * geometry - {} * style - {Object} * featureId - {String} */ drawGeometry: function(geometry, style, featureId) { var className = geometry.CLASS_NAME; if ((className == "OpenLayers.Geometry.Collection") || (className == "OpenLayers.Geometry.MultiPoint") || (className == "OpenLayers.Geometry.MultiLineString") || (className == "OpenLayers.Geometry.MultiPolygon")) { for (var i = 0; i < geometry.components.length; i++) { this.drawGeometry(geometry.components[i], style, featureId); } return; }; if (style.display != "none") { //first we create the basic node and add it to the root var nodeType = this.getNodeType(geometry, style); var node = this.nodeFactory(geometry.id, nodeType); node._featureId = featureId; node._geometryClass = geometry.CLASS_NAME; node._style = style; //now actually draw the node, and style it node = this.drawGeometryNode(node, geometry); // append the node to root (but only if it's new) if (node.parentNode != this.root) { this.root.appendChild(node); } this.postDraw(node); } else { node = OpenLayers.Util.getElement(geometry.id); if (node) { node.parentNode.removeChild(node); } } }, /** * Method: drawGeometryNode * Given a node, draw a geometry on the specified layer. * node and geometry are required arguments, style is optional. * This method is only called by the render itself. * * Parameters: * node - {DOMElement} * geometry - {} * style - {Object} */ drawGeometryNode: function(node, geometry, style) { style = style || node._style; OpenLayers.Util.applyDefaults(style, this.minimumSymbolizer); var options = { 'isFilled': true, 'isStroked': !!style.strokeWidth }; switch (geometry.CLASS_NAME) { case "OpenLayers.Geometry.Point": this.drawPoint(node, geometry); break; case "OpenLayers.Geometry.LineString": options.isFilled = false; this.drawLineString(node, geometry); break; case "OpenLayers.Geometry.LinearRing": this.drawLinearRing(node, geometry); break; case "OpenLayers.Geometry.Polygon": this.drawPolygon(node, geometry); break; case "OpenLayers.Geometry.Surface": this.drawSurface(node, geometry); break; case "OpenLayers.Geometry.Path": this.drawPath(node, geometry); break; case "OpenLayers.Geometry.PathGroup": this.drawPathGroup(node, geometry); break; case "OpenLayers.Geometry.Rectangle": this.drawRectangle(node, geometry); break; default: break; } node._style = style; node._options = options; //set style //TBD simplify this return this.setStyle(node, style, options, geometry); }, /** * Method: postDraw * Things that have do be done after the geometry node is appended * to its parent node. To be overridden by subclasses. * * Parameters: * node - {DOMElement} */ postDraw: function(node) {}, /** * Method: drawPoint * Virtual function for drawing Point Geometry. * Should be implemented by subclasses. * This method is only called by the renderer itself. * * Parameters: * node - {DOMElement} * geometry - {} */ drawPoint: function(node, geometry) {}, /** * Method: drawLineString * Virtual function for drawing LineString Geometry. * Should be implemented by subclasses. * This method is only called by the renderer itself. * * Parameters: * node - {DOMElement} * geometry - {} */ drawLineString: function(node, geometry) {}, /** * Method: drawLinearRing * Virtual function for drawing LinearRing Geometry. * Should be implemented by subclasses. * This method is only called by the renderer itself. * * Parameters: * node - {DOMElement} * geometry - {} */ drawLinearRing: function(node, geometry) {}, /** * Method: drawPolygon * Virtual function for drawing Polygon Geometry. * Should be implemented by subclasses. * This method is only called by the renderer itself. * * Parameters: * node - {DOMElement} * geometry - {} */ drawPolygon: function(node, geometry) {}, /** * Method: drawRectangle * Virtual function for drawing Rectangle Geometry. * Should be implemented by subclasses. * This method is only called by the renderer itself. * * Parameters: * node - {DOMElement} * geometry - {} */ drawRectangle: function(node, geometry) {}, /** * Method: drawCircle * Virtual function for drawing Circle Geometry. * Should be implemented by subclasses. * This method is only called by the renderer itself. * * Parameters: * node - {DOMElement} * geometry - {} */ drawCircle: function(node, geometry) {}, /** * Method: drawSurface * Virtual function for drawing Surface Geometry. * Should be implemented by subclasses. * This method is only called by the renderer itself. * * Parameters: * node - {DOMElement} * geometry - {} */ drawSurface: function(node, geometry) {}, /** * Method: getFeatureIdFromEvent * * Parameters: * evt - {Object} An object * * Returns: * {} A geometry from an event that * happened on a layer */ getFeatureIdFromEvent: function(evt) { var node = evt.target || evt.srcElement; return node._featureId; }, /** * Method: eraseGeometry * Erase a geometry from the renderer. In the case of a multi-geometry, * we cycle through and recurse on ourselves. Otherwise, we look for a * node with the geometry.id, destroy its geometry, and remove it from * the DOM. * * Parameters: * geometry - {} */ eraseGeometry: function(geometry) { if ((geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPoint") || (geometry.CLASS_NAME == "OpenLayers.Geometry.MultiLineString") || (geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPolygon")) { for (var i = 0; i < geometry.components.length; i++) { this.eraseGeometry(geometry.components[i]); } } else { var element = OpenLayers.Util.getElement(geometry.id); if (element && element.parentNode) { element.parentNode.removeChild(element); } } }, /** * Method: nodeFactory * Create new node of the specified type, with the (optional) specified id. * * If node already exists with same ID and type, we remove it and then * call ourselves again to recreate it. * * Parameters: * id - {String} * type - {String} type Kind of node to draw * * Returns: * {DOMElement} A new node of the given type and id */ nodeFactory: function(id, type) { var node = OpenLayers.Util.getElement(id); if (node) { if (!this.nodeTypeCompare(node, type)) { node.parentNode.removeChild(node); node = this.nodeFactory(id, type); } } else { node = this.createNode(type, id); } return node; }, CLASS_NAME: "OpenLayers.Renderer.Elements" }); /* ====================================================================== OpenLayers/Tile.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /* * @requires OpenLayers/Util.js */ /* * Class: OpenLayers.Tile * This is a class designed to designate a single tile, however * it is explicitly designed to do relatively little. Tiles store * information about themselves -- such as the URL that they are related * to, and their size - but do not add themselves to the layer div * automatically, for example. Create a new tile with the * constructor, or a subclass. * * TBD 3.0 - remove reference to url in above paragraph * */ OpenLayers.Tile = OpenLayers.Class({ /** * Constant: EVENT_TYPES * {Array(String)} Supported application event types */ EVENT_TYPES: [ "loadstart", "loadend", "reload", "unload"], /** * APIProperty: events * {} An events object that handles all * events on the tile. */ events: null, /** * Property: id * {String} null */ id: null, /** * Property: layer * {} layer the tile is attached to */ layer: null, /** * Property: url * {String} url of the request. * * TBD 3.0 * Deprecated. The base tile class does not need an url. This should be * handled in subclasses. Does not belong here. */ url: null, /** * APIProperty: bounds * {} null */ bounds: null, /** * Property: size * {} null */ size: null, /** * Property: position * {} Top Left pixel of the tile */ position: null, /** * Property: isLoading * {Boolean} Is the tile loading? */ isLoading: false, /** * Property: isBackBuffer * {Boolean} Is this tile a back buffer tile? */ isBackBuffer: false, /** * Property: lastRatio * {Float} Used in transition code only. This is the previous ratio * of the back buffer tile resolution to the map resolution. Compared * with the current ratio to determine if zooming occurred. */ lastRatio: 1, /** * Property: isFirstDraw * {Boolean} Is this the first time the tile is being drawn? * This is used to force resetBackBuffer to synchronize * the backBufferTile with the foreground tile the first time * the foreground tile loads so that if the user zooms * before the layer has fully loaded, the backBufferTile for * tiles that have been loaded can be used. */ isFirstDraw: true, /** * Property: backBufferTile * {} A clone of the tile used to create transition * effects when the tile is moved or changes resolution. */ backBufferTile: null, /** TBD 3.0 -- remove 'url' from the list of parameters to the constructor. * there is no need for the base tile class to have a url. * * Constructor: OpenLayers.Tile * Constructor for a new instance. * * Parameters: * layer - {} layer that the tile will go in. * position - {} * bounds - {} * url - {} * size - {} */ initialize: function(layer, position, bounds, url, size) { this.layer = layer; this.position = position.clone(); this.bounds = bounds.clone(); this.url = url; this.size = size.clone(); //give the tile a unique id based on its BBOX. this.id = OpenLayers.Util.createUniqueID("Tile_"); this.events = new OpenLayers.Events(this, null, this.EVENT_TYPES); }, /** * Method: unload * Call immediately before destroying if you are listening to tile * events, so that counters are properly handled if tile is still * loading at destroy-time. Will only fire an event if the tile is * still loading. */ unload: function() { if (this.isLoading) { this.isLoading = false; this.events.triggerEvent("unload"); } }, /** * APIMethod: destroy * Nullify references to prevent circular references and memory leaks. */ destroy:function() { if (OpenLayers.Util.indexOf(this.layer.SUPPORTED_TRANSITIONS, this.layer.transitionEffect) != -1) { this.layer.events.unregister("loadend", this, this.resetBackBuffer); this.events.unregister('loadend', this, this.resetBackBuffer); } else { this.events.unregister('loadend', this, this.showTile); } this.layer = null; this.bounds = null; this.size = null; this.position = null; this.events.destroy(); this.events = null; /* clean up the backBufferTile if it exists */ if (this.backBufferTile) { this.backBufferTile.destroy(); this.backBufferTile = null; } }, /** * Method: clone * * Parameters: * obj - {} The tile to be cloned * * Returns: * {} An exact clone of this */ clone: function (obj) { if (obj == null) { obj = new OpenLayers.Tile(this.layer, this.position, this.bounds, this.url, this.size); } // catch any randomly tagged-on properties OpenLayers.Util.applyDefaults(obj, this); return obj; }, /** * Method: draw * Clear whatever is currently in the tile, then return whether or not * it should actually be re-drawn. * * Returns: * {Boolean} Whether or not the tile should actually be drawn. Note that * this is not really the best way of doing things, but such is * the way the code has been developed. Subclasses call this and * depend on the return to know if they should draw or not. */ draw: function() { var maxExtent = this.layer.maxExtent; var withinMaxExtent = (maxExtent && this.bounds.intersectsBounds(maxExtent, false)); // The only case where we *wouldn't* want to draw the tile is if the // tile is outside its layer's maxExtent. var drawTile = (withinMaxExtent || this.layer.displayOutsideMaxExtent); if (OpenLayers.Util.indexOf(this.layer.SUPPORTED_TRANSITIONS, this.layer.transitionEffect) != -1) { if (drawTile) { //we use a clone of this tile to create a double buffer for visual //continuity. The backBufferTile is used to create transition //effects while the tile in the grid is repositioned and redrawn if (!this.backBufferTile) { this.backBufferTile = this.clone(); this.backBufferTile.hide(); // this is important. It allows the backBuffer to place itself // appropriately in the DOM. The Image subclass needs to put // the backBufferTile behind the main tile so the tiles can // load over top and display as soon as they are loaded. this.backBufferTile.isBackBuffer = true; // potentially end any transition effects when the tile loads this.events.register('loadend', this, this.resetBackBuffer); // clear transition back buffer tile only after all tiles in // this layer have loaded to avoid visual glitches this.layer.events.register("loadend", this, this.resetBackBuffer); } // run any transition effects this.startTransition(); } else { // if we aren't going to draw the tile, then the backBuffer should // be hidden too! if (this.backBufferTile) { this.backBufferTile.clear(); } } } else { if (drawTile && this.isFirstDraw) { this.events.register('loadend', this, this.showTile); this.isFirstDraw = false; } } this.shouldDraw = drawTile; //clear tile's contents and mark as not drawn this.clear(); return drawTile; }, /** * Method: moveTo * Reposition the tile. * * Parameters: * bounds - {} * position - {} * redraw - {Boolean} Call draw method on tile after moving. * Default is true */ moveTo: function (bounds, position, redraw) { if (redraw == null) { redraw = true; } this.bounds = bounds.clone(); this.position = position.clone(); if (redraw) { this.draw(); } }, /** * Method: clear * Clear the tile of any bounds/position-related data so that it can * be reused in a new location. To be implemented by subclasses. */ clear: function() { // to be implemented by subclasses }, /** * Method: getBoundsFromBaseLayer * Take the pixel locations of the corner of the tile, and pass them to * the base layer and ask for the location of those pixels, so that * displaying tiles over Google works fine. * * Parameters: * position - {} * * Returns: * bounds - {} */ getBoundsFromBaseLayer: function(position) { var msg = OpenLayers.i18n('reprojectDeprecated', {'layerName':this.layer.name}); OpenLayers.Console.warn(msg); var topLeft = this.layer.map.getLonLatFromLayerPx(position); var bottomRightPx = position.clone(); bottomRightPx.x += this.size.w; bottomRightPx.y += this.size.h; var bottomRight = this.layer.map.getLonLatFromLayerPx(bottomRightPx); // Handle the case where the base layer wraps around the date line. // Google does this, and it breaks WMS servers to request bounds in // that fashion. if (topLeft.lon > bottomRight.lon) { if (topLeft.lon < 0) { topLeft.lon = -180 - (topLeft.lon+180); } else { bottomRight.lon = 180+bottomRight.lon+180; } } var bounds = new OpenLayers.Bounds(topLeft.lon, bottomRight.lat, bottomRight.lon, topLeft.lat); return bounds; }, /** * Method: startTransition * Prepare the tile for a transition effect. To be * implemented by subclasses. */ startTransition: function() {}, /** * Method: resetBackBuffer * Triggered by two different events, layer loadend, and tile loadend. * In any of these cases, we check to see if we can hide the * backBufferTile yet and update its parameters to match the * foreground tile. * * Basic logic: * - If the backBufferTile hasn't been drawn yet, reset it * - If layer is still loading, show foreground tile but don't hide * the backBufferTile yet * - If layer is done loading, reset backBuffer tile and show * foreground tile */ resetBackBuffer: function() { this.showTile(); if (this.backBufferTile && (this.isFirstDraw || !this.layer.numLoadingTiles)) { this.isFirstDraw = false; // check to see if the backBufferTile is within the max extents // before rendering it var maxExtent = this.layer.maxExtent; var withinMaxExtent = (maxExtent && this.bounds.intersectsBounds(maxExtent, false)); if (withinMaxExtent) { this.backBufferTile.position = this.position; this.backBufferTile.bounds = this.bounds; this.backBufferTile.size = this.size; this.backBufferTile.imageSize = this.layer.imageSize || this.size; this.backBufferTile.imageOffset = this.layer.imageOffset; this.backBufferTile.resolution = this.layer.getResolution(); this.backBufferTile.renderTile(); } } }, /** * Method: showTile * Show the tile only if it should be drawn. */ showTile: function() { if (this.shouldDraw) { this.show(); } }, /** * Method: show * Show the tile. To be implemented by subclasses. */ show: function() { }, /** * Method: hide * Hide the tile. To be implemented by subclasses. */ hide: function() { }, CLASS_NAME: "OpenLayers.Tile" }); /* ====================================================================== OpenLayers/Control/MouseToolbar.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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 * @requires OpenLayers/Control/MouseDefaults.js */ /** * Class: OpenLayers.Control.MouseToolbar * This class is DEPRECATED in 2.4 and will be removed by 3.0. * If you need this functionality, use Control.NavToolbar instead!!! */ OpenLayers.Control.MouseToolbar = OpenLayers.Class( OpenLayers.Control.MouseDefaults, { /** * Property: mode */ mode: null, /** * Property: buttons */ buttons: null, /** * APIProperty: direction * {String} 'vertical' or 'horizontal' */ direction: "vertical", /** * Property: buttonClicked * {String} */ buttonClicked: null, /** * Constructor: OpenLayers.Control.MouseToolbar * * Parameters: * position - {} * direction - {String} */ initialize: function(position, direction) { OpenLayers.Control.prototype.initialize.apply(this, arguments); this.position = new OpenLayers.Pixel(OpenLayers.Control.MouseToolbar.X, OpenLayers.Control.MouseToolbar.Y); if (position) { this.position = position; } if (direction) { this.direction = direction; } this.measureDivs = []; }, /** * APIMethod: destroy */ destroy: function() { for( var btnId in this.buttons) { var btn = this.buttons[btnId]; btn.map = null; btn.events.destroy(); } OpenLayers.Control.MouseDefaults.prototype.destroy.apply(this, arguments); }, /** * Method: draw */ draw: function() { OpenLayers.Control.prototype.draw.apply(this, arguments); OpenLayers.Control.MouseDefaults.prototype.draw.apply(this, arguments); this.buttons = {}; var sz = new OpenLayers.Size(28,28); var centered = new OpenLayers.Pixel(OpenLayers.Control.MouseToolbar.X,0); this._addButton("zoombox", "drag-rectangle-off.png", "drag-rectangle-on.png", centered, sz, "Shift->Drag to zoom to area"); centered = centered.add((this.direction == "vertical" ? 0 : sz.w), (this.direction == "vertical" ? sz.h : 0)); this._addButton("pan", "panning-hand-off.png", "panning-hand-on.png", centered, sz, "Drag the map to pan."); centered = centered.add((this.direction == "vertical" ? 0 : sz.w), (this.direction == "vertical" ? sz.h : 0)); this.switchModeTo("pan"); return this.div; }, /** * Method: _addButton */ _addButton:function(id, img, activeImg, xy, sz, title) { var imgLocation = OpenLayers.Util.getImagesLocation() + img; var activeImgLocation = OpenLayers.Util.getImagesLocation() + activeImg; // var btn = new ol.AlphaImage("_"+id, imgLocation, xy, sz); var btn = OpenLayers.Util.createAlphaImageDiv( "OpenLayers_Control_MouseToolbar_" + id, xy, sz, imgLocation, "absolute"); //we want to add the outer div this.div.appendChild(btn); btn.imgLocation = imgLocation; btn.activeImgLocation = activeImgLocation; btn.events = new OpenLayers.Events(this, btn, null, true); btn.events.on({ "mousedown": this.buttonDown, "mouseup": this.buttonUp, "dblclick": OpenLayers.Event.stop, scope: this }); btn.action = id; btn.title = title; btn.alt = title; btn.map = this.map; //we want to remember/reference the outer div this.buttons[id] = btn; return btn; }, /** * Method: buttonDown * * Parameters: * evt - {Event} */ buttonDown: function(evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } this.buttonClicked = evt.element.action; OpenLayers.Event.stop(evt); }, /** * Method: buttonUp * * Parameters: * evt - {Event} */ buttonUp: function(evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } if (this.buttonClicked != null) { if (this.buttonClicked == evt.element.action) { this.switchModeTo(evt.element.action); } OpenLayers.Event.stop(evt); this.buttonClicked = null; } }, /** * Method: defaultDblClick * * Parameters: * evt - {Event} */ defaultDblClick: function (evt) { this.switchModeTo("pan"); this.performedDrag = false; var newCenter = this.map.getLonLatFromViewPortPx( evt.xy ); this.map.setCenter(newCenter, this.map.zoom + 1); OpenLayers.Event.stop(evt); return false; }, /** * Method: defaultMouseDown * * Parameters: * evt - {Event} */ defaultMouseDown: function (evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } this.mouseDragStart = evt.xy.clone(); this.performedDrag = false; this.startViaKeyboard = false; if (evt.shiftKey && this.mode !="zoombox") { this.switchModeTo("zoombox"); this.startViaKeyboard = true; } else if (evt.altKey && this.mode !="measure") { this.switchModeTo("measure"); } else if (!this.mode) { this.switchModeTo("pan"); } switch (this.mode) { case "zoombox": this.map.div.style.cursor = "crosshair"; this.zoomBox = OpenLayers.Util.createDiv('zoomBox', this.mouseDragStart, null, null, "absolute", "2px solid red"); this.zoomBox.style.backgroundColor = "white"; this.zoomBox.style.filter = "alpha(opacity=50)"; // IE this.zoomBox.style.opacity = "0.50"; this.zoomBox.style.fontSize = "1px"; this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; this.map.viewPortDiv.appendChild(this.zoomBox); this.performedDrag = true; break; case "measure": var distance = ""; if (this.measureStart) { var measureEnd = this.map.getLonLatFromViewPortPx(this.mouseDragStart); distance = OpenLayers.Util.distVincenty(this.measureStart, measureEnd); distance = Math.round(distance * 100) / 100; distance = distance + "km"; this.measureStartBox = this.measureBox; } this.measureStart = this.map.getLonLatFromViewPortPx(this.mouseDragStart);; this.measureBox = OpenLayers.Util.createDiv(null, this.mouseDragStart.add( -2-parseInt(this.map.layerContainerDiv.style.left), -2-parseInt(this.map.layerContainerDiv.style.top)), null, null, "absolute"); this.measureBox.style.width="4px"; this.measureBox.style.height="4px"; this.measureBox.style.fontSize = "1px"; this.measureBox.style.backgroundColor="red"; this.measureBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; this.map.layerContainerDiv.appendChild(this.measureBox); if (distance) { this.measureBoxDistance = OpenLayers.Util.createDiv(null, this.mouseDragStart.add( -2-parseInt(this.map.layerContainerDiv.style.left), 2-parseInt(this.map.layerContainerDiv.style.top)), null, null, "absolute"); this.measureBoxDistance.innerHTML = distance; this.measureBoxDistance.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; this.map.layerContainerDiv.appendChild(this.measureBoxDistance); this.measureDivs.push(this.measureBoxDistance); } this.measureBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1; this.map.layerContainerDiv.appendChild(this.measureBox); this.measureDivs.push(this.measureBox); break; default: this.map.div.style.cursor = "move"; break; } document.onselectstart = function() { return false; }; OpenLayers.Event.stop(evt); }, /** * Method: switchModeTo * * Parameters: * mode - {String} */ switchModeTo: function(mode) { if (mode != this.mode) { if (this.mode && this.buttons[this.mode]) { OpenLayers.Util.modifyAlphaImageDiv(this.buttons[this.mode], null, null, null, this.buttons[this.mode].imgLocation); } if (this.mode == "measure" && mode != "measure") { for(var i = 0; i < this.measureDivs.length; i++) { if (this.measureDivs[i]) { this.map.layerContainerDiv.removeChild(this.measureDivs[i]); } } this.measureDivs = []; this.measureStart = null; } this.mode = mode; if (this.buttons[mode]) { OpenLayers.Util.modifyAlphaImageDiv(this.buttons[mode], null, null, null, this.buttons[mode].activeImgLocation); } switch (this.mode) { case "zoombox": this.map.div.style.cursor = "crosshair"; break; default: this.map.div.style.cursor = ""; break; } } }, /** * Method: leaveMode */ leaveMode: function() { this.switchModeTo("pan"); }, /** * Method: defaultMouseMove * * Parameters: * evt - {Event} */ defaultMouseMove: function (evt) { if (this.mouseDragStart != null) { switch (this.mode) { case "zoombox": var deltaX = Math.abs(this.mouseDragStart.x - evt.xy.x); var deltaY = Math.abs(this.mouseDragStart.y - evt.xy.y); this.zoomBox.style.width = Math.max(1, deltaX) + "px"; this.zoomBox.style.height = Math.max(1, deltaY) + "px"; if (evt.xy.x < this.mouseDragStart.x) { this.zoomBox.style.left = evt.xy.x+"px"; } if (evt.xy.y < this.mouseDragStart.y) { this.zoomBox.style.top = evt.xy.y+"px"; } break; default: var deltaX = this.mouseDragStart.x - evt.xy.x; var deltaY = this.mouseDragStart.y - evt.xy.y; var size = this.map.getSize(); var newXY = new OpenLayers.Pixel(size.w / 2 + deltaX, size.h / 2 + deltaY); var newCenter = this.map.getLonLatFromViewPortPx( newXY ); this.map.setCenter(newCenter, null, true); this.mouseDragStart = evt.xy.clone(); } this.performedDrag = true; } }, /** * Method: defaultMouseUp * * Parameters: * evt - {Event} */ defaultMouseUp: function (evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } switch (this.mode) { case "zoombox": this.zoomBoxEnd(evt); if (this.startViaKeyboard) { this.leaveMode(); } break; case "pan": if (this.performedDrag) { this.map.setCenter(this.map.center); } } document.onselectstart = null; this.mouseDragStart = null; this.map.div.style.cursor = "default"; }, /** * Method: defaultMouseOut * * Parameters: * evt - {Event} */ defaultMouseOut: function (evt) { if (this.mouseDragStart != null && OpenLayers.Util.mouseLeft(evt, this.map.div)) { if (this.zoomBox) { this.removeZoomBox(); if (this.startViaKeyboard) { this.leaveMode(); } } this.mouseDragStart = null; this.map.div.style.cursor = "default"; } }, /** * Method: defaultClick * * Parameters: * evt - {Event} */ defaultClick: function (evt) { if (this.performedDrag) { this.performedDrag = false; return false; } }, CLASS_NAME: "OpenLayers.Control.MouseToolbar" }); OpenLayers.Control.MouseToolbar.X = 6; OpenLayers.Control.MouseToolbar.Y = 300; /* ====================================================================== OpenLayers/Control/PanZoomBar.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., 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/PanZoom.js */ /** * Class: OpenLayers.Control.PanZoomBar * * Inherits from: * - */ OpenLayers.Control.PanZoomBar = OpenLayers.Class(OpenLayers.Control.PanZoom, { /** * APIProperty: zoomStopWidth */ zoomStopWidth: 18, /** * APIProperty: zoomStopHeight */ zoomStopHeight: 11, /** * Property: slider */ slider: null, /** * Property: sliderEvents * {} */ sliderEvents: null, /** * Property: zoomBarDiv * {DOMElement} */ zoomBarDiv: null, /** * Property: divEvents * {} */ divEvents: null, /** * Property: zoomWorldIcon * {Boolean} */ zoomWorldIcon: false, /** * Constructor: OpenLayers.Control.PanZoomBar */ initialize: function() { OpenLayers.Control.PanZoom.prototype.initialize.apply(this, arguments); }, /** * APIMethod: destroy */ destroy: function() { this.div.removeChild(this.slider); this.slider = null; this.sliderEvents.destroy(); this.sliderEvents = null; this.div.removeChild(this.zoombarDiv); this.zoomBarDiv = null; this.divEvents.destroy(); this.divEvents = null; this.map.events.un({ "zoomend": this.moveZoomBar, "changebaselayer": this.redraw, scope: this }); OpenLayers.Control.PanZoom.prototype.destroy.apply(this, arguments); }, /** * Method: setMap * * Parameters: * map - {} */ setMap: function(map) { OpenLayers.Control.PanZoom.prototype.setMap.apply(this, arguments); this.map.events.register("changebaselayer", this, this.redraw); }, /** * Method: redraw * clear the div and start over. */ redraw: function() { if (this.div != null) { this.div.innerHTML = ""; } this.draw(); }, /** * Method: draw * * Parameters: * px - {} */ draw: function(px) { // initialize our internal div OpenLayers.Control.prototype.draw.apply(this, arguments); px = this.position.clone(); // place the controls this.buttons = []; var sz = new OpenLayers.Size(18,18); var centered = new OpenLayers.Pixel(px.x+sz.w/2, px.y); var wposition = sz.w; if (this.zoomWorldIcon) { centered = new OpenLayers.Pixel(px.x+sz.w, px.y); } this._addButton("panup", "north-mini.png", centered, sz); px.y = centered.y+sz.h; this._addButton("panleft", "west-mini.png", px, sz); if (this.zoomWorldIcon) { this._addButton("zoomworld", "zoom-world-mini.png", px.add(sz.w, 0), sz); wposition *= 2; } this._addButton("panright", "east-mini.png", px.add(wposition, 0), sz); this._addButton("pandown", "south-mini.png", centered.add(0, sz.h*2), sz); this._addButton("zoomin", "zoom-plus-mini.png", centered.add(0, sz.h*3+5), sz); centered = this._addZoomBar(centered.add(0, sz.h*4 + 5)); this._addButton("zoomout", "zoom-minus-mini.png", centered, sz); return this.div; }, /** * Method: _addZoomBar * * Parameters: * location - {} where zoombar drawing is to start. */ _addZoomBar:function(centered) { var imgLocation = OpenLayers.Util.getImagesLocation(); var id = "OpenLayers_Control_PanZoomBar_Slider" + this.map.id; var zoomsToEnd = this.map.getNumZoomLevels() - 1 - this.map.getZoom(); var slider = OpenLayers.Util.createAlphaImageDiv(id, centered.add(-1, zoomsToEnd * this.zoomStopHeight), new OpenLayers.Size(20,9), imgLocation+"slider.png", "absolute"); this.slider = slider; this.sliderEvents = new OpenLayers.Events(this, slider, null, true); this.sliderEvents.on({ "mousedown": this.zoomBarDown, "mousemove": this.zoomBarDrag, "mouseup": this.zoomBarUp, "dblclick": this.doubleClick, "click": this.doubleClick }); var sz = new OpenLayers.Size(); sz.h = this.zoomStopHeight * this.map.getNumZoomLevels(); sz.w = this.zoomStopWidth; var div = null; if (OpenLayers.Util.alphaHack()) { var id = "OpenLayers_Control_PanZoomBar" + this.map.id; div = OpenLayers.Util.createAlphaImageDiv(id, centered, new OpenLayers.Size(sz.w, this.zoomStopHeight), imgLocation + "zoombar.png", "absolute", null, "crop"); div.style.height = sz.h; } else { div = OpenLayers.Util.createDiv( 'OpenLayers_Control_PanZoomBar_Zoombar' + this.map.id, centered, sz, imgLocation+"zoombar.png"); } this.zoombarDiv = div; this.divEvents = new OpenLayers.Events(this, div, null, true); this.divEvents.on({ "mousedown": this.divClick, "mousemove": this.passEventToSlider, "dblclick": this.doubleClick, "click": this.doubleClick }); this.div.appendChild(div); this.startTop = parseInt(div.style.top); this.div.appendChild(slider); this.map.events.register("zoomend", this, this.moveZoomBar); centered = centered.add(0, this.zoomStopHeight * this.map.getNumZoomLevels()); return centered; }, /* * Method: passEventToSlider * This function is used to pass events that happen on the div, or the map, * through to the slider, which then does its moving thing. * * Parameters: * evt - {} */ passEventToSlider:function(evt) { this.sliderEvents.handleBrowserEvent(evt); }, /* * Method: divClick * Picks up on clicks directly on the zoombar div * and sets the zoom level appropriately. */ divClick: function (evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } var y = evt.xy.y; var top = OpenLayers.Util.pagePosition(evt.object)[1]; var levels = (y - top)/this.zoomStopHeight; if(!this.map.fractionalZoom) { levels = Math.floor(levels); } var zoom = (this.map.getNumZoomLevels() - 1) - levels; zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1); this.map.zoomTo(zoom); OpenLayers.Event.stop(evt); }, /* * Method: zoomBarDown * event listener for clicks on the slider * * Parameters: * evt - {} */ zoomBarDown:function(evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } this.map.events.on({ "mousemove": this.passEventToSlider, "mouseup": this.passEventToSlider, scope: this }); this.mouseDragStart = evt.xy.clone(); this.zoomStart = evt.xy.clone(); this.div.style.cursor = "move"; // reset the div offsets just in case the div moved this.zoombarDiv.offsets = null; OpenLayers.Event.stop(evt); }, /* * Method: zoomBarDrag * This is what happens when a click has occurred, and the client is * dragging. Here we must ensure that the slider doesn't go beyond the * bottom/top of the zoombar div, as well as moving the slider to its new * visual location * * Parameters: * evt - {} */ zoomBarDrag:function(evt) { if (this.mouseDragStart != null) { var deltaY = this.mouseDragStart.y - evt.xy.y; var offsets = OpenLayers.Util.pagePosition(this.zoombarDiv); if ((evt.clientY - offsets[1]) > 0 && (evt.clientY - offsets[1]) < parseInt(this.zoombarDiv.style.height) - 2) { var newTop = parseInt(this.slider.style.top) - deltaY; this.slider.style.top = newTop+"px"; } this.mouseDragStart = evt.xy.clone(); OpenLayers.Event.stop(evt); } }, /* * Method: zoomBarUp * Perform cleanup when a mouseup event is received -- discover new zoom * level and switch to it. * * Parameters: * evt - {} */ zoomBarUp:function(evt) { if (!OpenLayers.Event.isLeftClick(evt)) { return; } if (this.zoomStart) { this.div.style.cursor=""; this.map.events.un({ "mouseup": this.passEventToSlider, "mousemove": this.passEventToSlider, scope: this }); var deltaY = this.zoomStart.y - evt.xy.y; var zoomLevel = this.map.zoom; if (this.map.fractionalZoom) { zoomLevel += deltaY/this.zoomStopHeight; zoomLevel = Math.min(Math.max(zoomLevel, 0), this.map.getNumZoomLevels() - 1); } else { zoomLevel += Math.round(deltaY/this.zoomStopHeight); } this.map.zoomTo(zoomLevel); this.moveZoomBar(); this.mouseDragStart = null; OpenLayers.Event.stop(evt); } }, /* * Method: moveZoomBar * Change the location of the slider to match the current zoom level. */ moveZoomBar:function() { var newTop = ((this.map.getNumZoomLevels()-1) - this.map.getZoom()) * this.zoomStopHeight + this.startTop + 1; this.slider.style.top = newTop + "px"; }, CLASS_NAME: "OpenLayers.Control.PanZoomBar" }); /* ====================================================================== OpenLayers/Format/JSON.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * Note: * This work draws heavily from the public domain JSON serializer/deserializer * at http://www.json.org/json.js. Rewritten so that it doesn't modify * basic data prototypes. */ /** * @requires OpenLayers/Format.js */ /** * Class: OpenLayers.Format.JSON * A parser to read/write JSON safely. Create a new instance with the * constructor. * * Inherits from: * - */ OpenLayers.Format.JSON = OpenLayers.Class(OpenLayers.Format, { /** * APIProperty: indent * {String} For "pretty" printing, the indent string will be used once for * each indentation level. */ indent: " ", /** * APIProperty: space * {String} For "pretty" printing, the space string will be used after * the ":" separating a name/value pair. */ space: " ", /** * APIProperty: newline * {String} For "pretty" printing, the newline string will be used at the * end of each name/value pair or array item. */ newline: "\n", /** * Property: level * {Integer} For "pretty" printing, this is incremented/decremented during * serialization. */ level: 0, /** * Property: pretty * {Boolean} Serialize with extra whitespace for structure. This is set * by the method. */ pretty: false, /** * Constructor: OpenLayers.Format.JSON * Create a new parser for JSON. * * Parameters: * options - {Object} An optional object whose properties will be set on * this instance. */ initialize: function(options) { OpenLayers.Format.prototype.initialize.apply(this, [options]); }, /** * APIMethod: read * Deserialize a json string. * * Parameters: * json - {String} A JSON string * filter - {Function} A function which will be called for every key and * value at every level of the final result. Each value will be * replaced by the result of the filter function. This can be used to * reform generic objects into instances of classes, or to transform * date strings into Date objects. * * Returns: * {Object} An object, array, string, or number . */ read: function(json, filter) { /** * Parsing happens in three stages. In the first stage, we run the text * against a regular expression which looks for non-JSON * characters. We are especially concerned with '()' and 'new' * because they can cause invocation, and '=' because it can cause * mutation. But just to be safe, we will reject all unexpected * characters. */ try { if (/^[\],:{}\s]*$/.test(json.replace(/\\["\\\/bfnrtu]/g, '@'). replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']'). replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) { /** * In the second stage we use the eval function to compile the * text into a JavaScript structure. The '{' operator is * subject to a syntactic ambiguity in JavaScript - it can * begin a block or an object literal. We wrap the text in * parens to eliminate the ambiguity. */ var object = eval('(' + json + ')'); /** * In the optional third stage, we recursively walk the new * structure, passing each name/value pair to a filter * function for possible transformation. */ if(typeof filter === 'function') { function walk(k, v) { if(v && typeof v === 'object') { for(var i in v) { if(v.hasOwnProperty(i)) { v[i] = walk(i, v[i]); } } } return filter(k, v); } object = walk('', object); } return object; } } catch(e) { // Fall through if the regexp test fails. } return null; }, /** * APIMethod: write * Serialize an object into a JSON string. * * Parameters: * value - {String} The object, array, string, number, boolean or date * to be serialized. * pretty - {Boolean} Structure the output with newlines and indentation. * Default is false. * * Returns: * {String} The JSON string representation of the input value. */ write: function(value, pretty) { this.pretty = !!pretty; var json = null; var type = typeof value; if(this.serialize[type]) { json = this.serialize[type].apply(this, [value]); } return json; }, /** * Method: writeIndent * Output an indentation string depending on the indentation level. * * Returns: * {String} An appropriate indentation string. */ writeIndent: function() { var pieces = []; if(this.pretty) { for(var i=0; i 0) { pieces.push(','); } pieces.push(this.writeNewline(), this.writeIndent(), json); } } this.level -= 1; pieces.push(this.writeNewline(), this.writeIndent(), ']'); return pieces.join(''); }, /** * Method: serialize.string * Transform a string into a JSON string. * * Parameters: * string - {String} The string to be serialized * * Returns: * {String} A JSON string representing the string. */ 'string': function(string) { // If the string contains no control characters, no quote characters, and no // backslash characters, then we can simply slap some quotes around it. // Otherwise we must also replace the offending characters with safe // sequences. var m = { '\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"' : '\\"', '\\': '\\\\' }; if(/["\\\x00-\x1f]/.test(string)) { return '"' + string.replace(/([\x00-\x1f\\"])/g, function(a, b) { var c = m[b]; if(c) { return c; } c = b.charCodeAt(); return '\\u00' + Math.floor(c / 16).toString(16) + (c % 16).toString(16); }) + '"'; } return '"' + string + '"'; }, /** * Method: serialize.number * Transform a number into a JSON string. * * Parameters: * number - {Number} The number to be serialized. * * Returns: * {String} A JSON string representing the number. */ 'number': function(number) { return isFinite(number) ? String(number) : "null"; }, /** * Method: serialize.boolean * Transform a boolean into a JSON string. * * Parameters: * bool - {Boolean} The boolean to be serialized. * * Returns: * {String} A JSON string representing the boolean. */ 'boolean': function(bool) { return String(bool); }, /** * Method: serialize.object * Transform a date into a JSON string. * * Parameters: * date - {Date} The date to be serialized. * * Returns: * {String} A JSON string representing the date. */ 'date': function(date) { function format(number) { // Format integers to have at least two digits. return (number < 10) ? '0' + number : number; } return '"' + date.getFullYear() + '-' + format(date.getMonth() + 1) + '-' + format(date.getDate()) + 'T' + format(date.getHours()) + ':' + format(date.getMinutes()) + ':' + format(date.getSeconds()) + '"'; } }, CLASS_NAME: "OpenLayers.Format.JSON" }); /* ====================================================================== OpenLayers/Format/XML.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Format.js */ /** * Class: OpenLayers.Format.XML * Read and write XML. For cross-browser XML generation, use methods on an * instance of the XML format class instead of on document. * The DOM creation and traversing methods exposed here all mimic the * W3C XML DOM methods. Create a new parser with the * constructor. * * Inherits from: * - */ OpenLayers.Format.XML = OpenLayers.Class(OpenLayers.Format, { /** * Property: xmldom * {XMLDom} If this browser uses ActiveX, this will be set to a XMLDOM * object. It is not intended to be a browser sniffing property. * Instead, the xmldom property is used instead of document * where namespaced node creation methods are not supported. In all * other browsers, this remains null. */ xmldom: null, /** * Constructor: OpenLayers.Format.XML * Construct an XML parser. The parser is used to read and write XML. * Reading XML from a string returns a DOM element. Writing XML from * a DOM element returns a string. * * Parameters: * options - {Object} Optional object whose properties will be set on * the object. */ initialize: function(options) { if(window.ActiveXObject) { this.xmldom = new ActiveXObject("Microsoft.XMLDOM"); } OpenLayers.Format.prototype.initialize.apply(this, [options]); }, /** * APIMethod: read * Deserialize a XML string and return a DOM node. * * Parameters: * text - {String} A XML string * Returns: * {DOMElement} A DOM node */ read: function(text) { var index = text.indexOf('<'); if(index > 0) { text = text.substring(index); } var node = OpenLayers.Util.Try( OpenLayers.Function.bind(( function() { var xmldom; /** * Since we want to be able to call this method on the prototype * itself, this.xmldom may not exist even if in IE. */ if(window.ActiveXObject && !this.xmldom) { xmldom = new ActiveXObject("Microsoft.XMLDOM"); } else { xmldom = this.xmldom; } xmldom.loadXML(text); return xmldom; } ), this), function() { return new DOMParser().parseFromString(text, 'text/xml'); }, function() { var req = new XMLHttpRequest(); req.open("GET", "data:" + "text/xml" + ";charset=utf-8," + encodeURIComponent(text), false); if(req.overrideMimeType) { req.overrideMimeType("text/xml"); } req.send(null); return req.responseXML; } ); return node; }, /** * APIMethod: write * Serialize a DOM node into a XML string. * * Parameters: * node - {DOMElement} A DOM node. * * Returns: * {String} The XML string representation of the input node. */ write: function(node) { var data; if(this.xmldom) { data = node.xml; } else { var serializer = new XMLSerializer(); if (node.nodeType == 1) { // Add nodes to a document before serializing. Everything else // is serialized as is. This may need more work. See #1218 . var doc = document.implementation.createDocument("", "", null); if (doc.importNode) { node = doc.importNode(node, true); } doc.appendChild(node); data = serializer.serializeToString(doc); } else { data = serializer.serializeToString(node); } } return data; }, /** * APIMethod: createElementNS * Create a new element with namespace. This node can be appended to * another node with the standard node.appendChild method. For * cross-browser support, this method must be used instead of * document.createElementNS. * * Parameters: * uri - {String} Namespace URI for the element. * name - {String} The qualified name of the element (prefix:localname). * * Returns: * {Element} A DOM element with namespace. */ createElementNS: function(uri, name) { var element; if(this.xmldom) { if(typeof uri == "string") { element = this.xmldom.createNode(1, name, uri); } else { element = this.xmldom.createNode(1, name, ""); } } else { element = document.createElementNS(uri, name); } return element; }, /** * APIMethod: createTextNode * Create a text node. This node can be appended to another node with * the standard node.appendChild method. For cross-browser support, * this method must be used instead of document.createTextNode. * * Parameters: * text - {String} The text of the node. * * Returns: * {DOMElement} A DOM text node. */ createTextNode: function(text) { var node; if(this.xmldom) { node = this.xmldom.createTextNode(text); } else { node = document.createTextNode(text); } return node; }, /** * APIMethod: getElementsByTagNameNS * Get a list of elements on a node given the namespace URI and local name. * To return all nodes in a given namespace, use '*' for the name * argument. To return all nodes of a given (local) name, regardless * of namespace, use '*' for the uri argument. * * Parameters: * node - {Element} Node on which to search for other nodes. * uri - {String} Namespace URI. * name - {String} Local name of the tag (without the prefix). * * Returns: * {NodeList} A node list or array of elements. */ getElementsByTagNameNS: function(node, uri, name) { var elements = []; if(node.getElementsByTagNameNS) { elements = node.getElementsByTagNameNS(uri, name); } else { // brute force method var allNodes = node.getElementsByTagName("*"); var potentialNode, fullName; for(var i=0; i}. The control that initialized this handler. The * control is assumed to have a valid map property - that map is used * in the handler's own setMap method. */ control: null, /** * Property: map * {} */ map: null, /** * APIProperty: keyMask * {Integer} Use bitwise operators and one or more of the OpenLayers.Handler * constants to construct a keyMask. The keyMask is used by * . If the keyMask matches the combination of keys * down on an event, checkModifiers returns true. * * Example: * (code) * // handler only responds if the Shift key is down * handler.keyMask = OpenLayers.Handler.MOD_SHIFT; * * // handler only responds if Ctrl-Shift is down * handler.keyMask = OpenLayers.Handler.MOD_SHIFT | * OpenLayers.Handler.MOD_CTRL; * (end) */ keyMask: null, /** * Property: active * {Boolean} */ active: false, /** * Property: evt * {Event} This property references the last event handled by the handler. * Note that this property is not part of the stable API. Use of the * evt property should be restricted to controls in the library * or other applications that are willing to update with changes to * the OpenLayers code. */ evt: null, /** * Constructor: OpenLayers.Handler * Construct a handler. * * Parameters: * control - {} The control that initialized this * handler. The control is assumed to have a valid map property; that * map is used in the handler's own setMap method. * callbacks - {Object} An object whose properties correspond to abstracted * events or sequences of browser events. The values for these * properties are functions defined by the control that get called by * the handler. * options - {Object} An optional object whose properties will be set on * the handler. */ initialize: function(control, callbacks, options) { OpenLayers.Util.extend(this, options); this.control = control; this.callbacks = callbacks; if (control.map) { this.setMap(control.map); } OpenLayers.Util.extend(this, options); this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); }, /** * Method: setMap */ setMap: function (map) { this.map = map; }, /** * Method: checkModifiers * Check the keyMask on the handler. If no is set, this always * returns true. If a is set and it matches the combination * of keys down on an event, this returns true. * * Returns: * {Boolean} The keyMask matches the keys down on an event. */ checkModifiers: function (evt) { if(this.keyMask == null) { return true; } /* calculate the keyboard modifier mask for this event */ var keyModifiers = (evt.shiftKey ? OpenLayers.Handler.MOD_SHIFT : 0) | (evt.ctrlKey ? OpenLayers.Handler.MOD_CTRL : 0) | (evt.altKey ? OpenLayers.Handler.MOD_ALT : 0); /* if it differs from the handler object's key mask, bail out of the event handler */ return (keyModifiers == this.keyMask); }, /** * APIMethod: activate * Turn on the handler. Returns false if the handler was already active. * * Returns: * {Boolean} The handler was activated. */ activate: function() { if(this.active) { return false; } // register for event handlers defined on this class. var events = OpenLayers.Events.prototype.BROWSER_EVENTS; for (var i = 0; i < events.length; i++) { if (this[events[i]]) { this.register(events[i], this[events[i]]); } } this.active = true; return true; }, /** * APIMethod: deactivate * Turn off the handler. Returns false if the handler was already inactive. * * Returns: * {Boolean} The handler was deactivated. */ deactivate: function() { if(!this.active) { return false; } // unregister event handlers defined on this class. var events = OpenLayers.Events.prototype.BROWSER_EVENTS; for (var i = 0; i < events.length; i++) { if (this[events[i]]) { this.unregister(events[i], this[events[i]]); } } this.active = false; return true; }, /** * Method: callback * Trigger the control's named callback with the given arguments * * Parameters: * name - {String} The key for the callback that is one of the properties * of the handler's callbacks object. * args - {Array(*)} An array of arguments (any type) with which to call * the callback (defined by the control). */ callback: function (name, args) { if (name && this.callbacks[name]) { this.callbacks[name].apply(this.control, args); } }, /** * Method: register * register an event on the map */ register: function (name, method) { // TODO: deal with registerPriority in 3.0 this.map.events.registerPriority(name, this, method); this.map.events.registerPriority(name, this, this.setEvent); }, /** * Method: unregister * unregister an event from the map */ unregister: function (name, method) { this.map.events.unregister(name, this, method); this.map.events.unregister(name, this, this.setEvent); }, /** * Method: setEvent * With each registered browser event, the handler sets its own evt * property. This property can be accessed by controls if needed * to get more information about the event that the handler is * processing. * * This allows modifier keys on the event to be checked (alt, shift, * and ctrl cannot be checked with the keyboard handler). For a * control to determine which modifier keys are associated with the * event that a handler is currently processing, it should access * (code)handler.evt.altKey || handler.evt.shiftKey || * handler.evt.ctrlKey(end). * * Parameters: * evt - {Event} The browser event. */ setEvent: function(evt) { this.evt = evt; return true; }, /** * Method: destroy * Deconstruct the handler. */ destroy: function () { // unregister event listeners this.deactivate(); // eliminate circular references this.control = this.map = null; }, CLASS_NAME: "OpenLayers.Handler" }); /** * Constant: OpenLayers.Handler.MOD_NONE * If set as the , returns false if any key is down. */ OpenLayers.Handler.MOD_NONE = 0; /** * Constant: OpenLayers.Handler.MOD_SHIFT * If set as the , returns false if Shift is down. */ OpenLayers.Handler.MOD_SHIFT = 1; /** * Constant: OpenLayers.Handler.MOD_CTRL * If set as the , returns false if Ctrl is down. */ OpenLayers.Handler.MOD_CTRL = 2; /** * Constant: OpenLayers.Handler.MOD_ALT * If set as the , returns false if Alt is down. */ OpenLayers.Handler.MOD_ALT = 4; /* ====================================================================== OpenLayers/Map.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Util.js * @requires OpenLayers/Events.js * @requires OpenLayers/Tween.js */ /** * Class: OpenLayers.Map * Instances of OpenLayers.Map are interactive maps embedded in a web page. * Create a new map with the constructor. * * On their own maps do not provide much functionality. To extend a map * it's necessary to add controls () and * layers () to the map. */ OpenLayers.Map = OpenLayers.Class({ /** * Constant: Z_INDEX_BASE * {Object} Base z-indexes for different classes of thing */ Z_INDEX_BASE: { BaseLayer: 100, Overlay: 325, Popup: 750, Control: 1000 }, /** * Constant: EVENT_TYPES * {Array(String)} Supported application event types. Register a listener * for a particular event with the following syntax: * (code) * map.events.register(type, obj, listener); * (end) * * Listeners will be called with a reference to an event object. The * properties of this event depends on exactly what happened. * * All event objects have at least the following properties: * - *object* {Object} A reference to map.events.object. * - *element* {DOMElement} A reference to map.events.element. * * Browser events have the following additional properties: * - *xy* {} The pixel location of the event (relative * to the the map viewport). * - other properties that come with browser events * * Supported map event types: * - *preaddlayer* triggered before a layer has been added. The event * object will include a *layer* property that references the layer * to be added. * - *addlayer* triggered after a layer has been added. The event object * will include a *layer* property that references the added layer. * - *removelayer* triggered after a layer has been removed. The event * object will include a *layer* property that references the removed * layer. * - *changelayer* triggered after a layer name change, order change, or * visibility change (due to resolution thresholds). Listeners will * receive an event object with *layer* and *property* properties. The * *layer* property will be a reference to the changed layer. The * *property* property will be a key to the changed property (name, * visibility, or order). * - *movestart* triggered after the start of a drag, pan, or zoom * - *move* triggered after each drag, pan, or zoom * - *moveend* triggered after a drag, pan, or zoom completes * - *popupopen* triggered after a popup opens * - *popupclose* triggered after a popup opens * - *addmarker* triggered after a marker has been added * - *removemarker* triggered after a marker has been removed * - *clearmarkers* triggered after markers have been cleared * - *mouseover* triggered after mouseover the map * - *mouseout* triggered after mouseout the map * - *mousemove* triggered after mousemove the map * - *dragstart* triggered after the start of a drag * - *drag* triggered after a drag * - *dragend* triggered after the end of a drag * - *changebaselayer* triggered after the base layer changes */ EVENT_TYPES: [ "preaddlayer", "addlayer", "removelayer", "changelayer", "movestart", "move", "moveend", "zoomend", "popupopen", "popupclose", "addmarker", "removemarker", "clearmarkers", "mouseover", "mouseout", "mousemove", "dragstart", "drag", "dragend", "changebaselayer"], /** * Property: id * {String} Unique identifier for the map */ id: null, /** * Property: fractionalZoom * {Boolean} For a base layer that supports it, allow the map resolution * to be set to a value between one of the values in the resolutions * array. Default is false. * * When fractionalZoom is set to true, it is possible to zoom to * an arbitrary extent. This requires a base layer from a source * that supports requests for arbitrary extents (i.e. not cached * tiles on a regular lattice). This means that fractionalZoom * will not work with commercial layers (Google, Yahoo, VE), layers * using TileCache, or any other pre-cached data sources. * * If you are using fractionalZoom, then you should also use * instead of layer.resolutions[zoom] as the * former works for non-integer zoom levels. */ fractionalZoom: false, /** * APIProperty: events * {} An events object that handles all * events on the map */ events: null, /** * APIProperty: div * {DOMElement} The element that contains the map */ div: null, /** * Property: dragging * {Boolean} The map is currently being dragged. */ dragging: false, /** * Property: size * {} Size of the main div (this.div) */ size: null, /** * Property: viewPortDiv * {HTMLDivElement} The element that represents the map viewport */ viewPortDiv: null, /** * Property: layerContainerOrigin * {} The lonlat at which the later container was * re-initialized (on-zoom) */ layerContainerOrigin: null, /** * Property: layerContainerDiv * {HTMLDivElement} The element that contains the layers. */ layerContainerDiv: null, /** * APIProperty: layers * {Array()} Ordered list of layers in the map */ layers: null, /** * Property: controls * {Array()} List of controls associated with the map */ controls: null, /** * Property: popups * {Array()} List of popups associated with the map */ popups: null, /** * APIProperty: baseLayer * {} The currently selected base layer. This determines * min/max zoom level, projection, etc. */ baseLayer: null, /** * Property: center * {} The current center of the map */ center: null, /** * Property: resolution * {Float} The resolution of the map. */ resolution: null, /** * Property: zoom * {Integer} The current zoom level of the map */ zoom: 0, /** * Property: viewRequestID * {String} Used to store a unique identifier that changes when the map * view changes. viewRequestID should be used when adding data * asynchronously to the map: viewRequestID is incremented when * you initiate your request (right now during changing of * baselayers and changing of zooms). It is stored here in the * map and also in the data that will be coming back * asynchronously. Before displaying this data on request * completion, we check that the viewRequestID of the data is * still the same as that of the map. Fix for #480 */ viewRequestID: 0, // Options /** * APIProperty: tileSize * {} Set in the map options to override the default tile * size for this map. */ tileSize: null, /** * APIProperty: projection * {String} Set in the map options to override the default projection * string this map - also set maxExtent, maxResolution, and * units if appropriate. */ projection: "EPSG:4326", /** * APIProperty: units * {String} The map units. Defaults to 'degrees'. Possible values are * 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. */ units: 'degrees', /** * APIProperty: resolutions * {Array(Float)} A list of map resolutions (map units per pixel) in * descending order. If this is not set in the layer constructor, it * will be set based on other resolution related properties * (maxExtent, maxResolution, maxScale, etc.). */ resolutions: null, /** * APIProperty: maxResolution * {Float} Default max is 360 deg / 256 px, which corresponds to * zoom level 0 on gmaps. Specify a different value in the map * options if you are not using a geographic projection and * displaying the whole world. */ maxResolution: 1.40625, /** * APIProperty: minResolution * {Float} */ minResolution: null, /** * APIProperty: maxScale * {Float} */ maxScale: null, /** * APIProperty: minScale * {Float} */ minScale: null, /** * APIProperty: maxExtent * {} The maximum extent for the map. Defaults to the * whole world in decimal degrees * (-180, -90, 180, 90). Specify a different * extent in the map options if you are not using a * geographic projection and displaying the whole * world. */ maxExtent: null, /** * APIProperty: minExtent * {} */ minExtent: null, /** * APIProperty: restrictedExtent * {} Limit map navigation to this extent where possible. * If a non-null restrictedExtent is set, panning will be restricted * to the given bounds. In addition, zooming to a resolution that * displays more than the restricted extent will center the map * on the restricted extent. If you wish to limit the zoom level * or resolution, use maxResolution. */ restrictedExtent: null, /** * APIProperty: numZoomLevels * {Integer} Number of zoom levels for the map. Defaults to 16. Set a * different value in the map options if needed. */ numZoomLevels: 16, /** * APIProperty: theme * {String} Relative path to a CSS file from which to load theme styles. * Specify null in the map options (e.g. {theme: null}) if you * want to get cascading style declarations - by putting links to * stylesheets or style declarations directly in your page. */ theme: null, /** * APIProperty: displayProjection * {} Requires proj4js support.Projection used by * several controls to display data to user. If this property is set, * it will be set on any control which has a null displayProjection * property at the time the control is added to the map. */ displayProjection: null, /** * APIProperty: fallThrough * {Boolean} Should OpenLayers allow events on the map to fall through to * other elements on the page, or should it swallow them? (#457) * Default is to fall through. */ fallThrough: true, /** * Property: panTween * {OpenLayers.Tween} Animated panning tween object, see panTo() */ panTween: null, /** * APIProperty: eventListeners * {Object} If set as an option at construction, the eventListeners * object will be registered with . Object * structure must be a listeners object as shown in the example for * the events.on method. */ eventListeners: null, /** * Property: panMethod * {Function} The Easing function to be used for tweening. Default is * OpenLayers.Easing.Expo.easeOut. Setting this to 'null' turns off * animated panning. */ panMethod: OpenLayers.Easing.Expo.easeOut, /** * Property: paddingForPopups * {} Outside margin of the popup. Used to prevent * the popup from getting too close to the map border. */ paddingForPopups : null, /** * Constructor: OpenLayers.Map * Constructor for a new OpenLayers.Map instance. * * Parameters: * div - {String} Id of an element in your page that will contain the map. * options - {Object} Optional object with properties to tag onto the map. * * Examples: * (code) * // create a map with default options in an element with the id "map1" * var map = new OpenLayers.Map("map1"); * * // create a map with non-default options in an element with id "map2" * var options = { * maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000), * maxResolution: 156543, * units: 'm', * projection: "EPSG:41001" * }; * var map = new OpenLayers.Map("map2", options); * (end) */ initialize: function (div, options) { // Simple-type defaults are set in class definition. // Now set complex-type defaults this.tileSize = new OpenLayers.Size(OpenLayers.Map.TILE_WIDTH, OpenLayers.Map.TILE_HEIGHT); this.maxExtent = new OpenLayers.Bounds(-180, -90, 180, 90); this.paddingForPopups = new OpenLayers.Bounds(15, 15, 15, 15); this.theme = OpenLayers._getScriptLocation() + 'theme/default/style.css'; // now override default options OpenLayers.Util.extend(this, options); this.id = OpenLayers.Util.createUniqueID("OpenLayers.Map_"); this.div = OpenLayers.Util.getElement(div); // the viewPortDiv is the outermost div we modify var id = this.div.id + "_OpenLayers_ViewPort"; this.viewPortDiv = OpenLayers.Util.createDiv(id, null, null, null, "relative", null, "hidden"); this.viewPortDiv.style.width = "100%"; this.viewPortDiv.style.height = "100%"; this.viewPortDiv.className = "olMapViewport"; this.div.appendChild(this.viewPortDiv); // the layerContainerDiv is the one that holds all the layers id = this.div.id + "_OpenLayers_Container"; this.layerContainerDiv = OpenLayers.Util.createDiv(id); this.layerContainerDiv.style.zIndex=this.Z_INDEX_BASE['Popup']-1; this.viewPortDiv.appendChild(this.layerContainerDiv); this.events = new OpenLayers.Events(this, this.div, this.EVENT_TYPES, this.fallThrough); this.updateSize(); if(this.eventListeners instanceof Object) { this.events.on(this.eventListeners); } // update the map size and location before the map moves this.events.register("movestart", this, this.updateSize); // Because Mozilla does not support the "resize" event for elements // other than "window", we need to put a hack here. if (OpenLayers.String.contains(navigator.appName, "Microsoft")) { // If IE, register the resize on the div this.events.register("resize", this, this.updateSize); } else { // Else updateSize on catching the window's resize // Note that this is ok, as updateSize() does nothing if the // map's size has not actually changed. this.updateSizeDestroy = OpenLayers.Function.bind(this.updateSize, this); OpenLayers.Event.observe(window, 'resize', this.updateSizeDestroy); } // only append link stylesheet if the theme property is set if(this.theme) { // check existing links for equivalent url var addNode = true; var nodes = document.getElementsByTagName('link'); for(var i=0; i=0; --i) { this.controls[i].destroy(); } this.controls = null; } if (this.layers != null) { for (var i = this.layers.length - 1; i>=0; --i) { //pass 'false' to destroy so that map wont try to set a new // baselayer after each baselayer is removed this.layers[i].destroy(false); } this.layers = null; } if (this.viewPortDiv) { this.div.removeChild(this.viewPortDiv); } this.viewPortDiv = null; if(this.eventListeners) { this.events.un(this.eventListeners); this.eventListeners = null; } this.events.destroy(); this.events = null; }, /** * APIMethod: setOptions * Change the map options * * Parameters: * options - {Object} Hashtable of options to tag to the map */ setOptions: function(options) { OpenLayers.Util.extend(this, options); }, /** * APIMethod: getTileSize * Get the tile size for the map * * Returns: * {} */ getTileSize: function() { return this.tileSize; }, /** * APIMethod: getBy * Get a list of objects given a property and a match item. * * Parameters: * array - {String} A property on the map whose value is an array. * property - {String} A property on each item of the given array. * match - {String | Object} A string to match. Can also be a regular * expression literal or object. In addition, it can be any object * with a method named test. For reqular expressions or other, if * match.test(map[array][i][property]) evaluates to true, the item will * be included in the array returned. If no items are found, an empty * array is returned. * * Returns: * {Array} An array of items where the given property matches the given * criteria. */ getBy: function(array, property, match) { var test = (typeof match.test == "function"); var found = OpenLayers.Array.filter(this[array], function(item) { return item[property] == match || (test && match.test(item[property])); }); return found; }, /** * APIMethod: getLayersBy * Get a list of layers with properties matching the given criteria. * * Parameter: * property - {String} A layer property to be matched. * match - {String | Object} A string to match. Can also be a regular * expression literal or object. In addition, it can be any object * with a method named test. For reqular expressions or other, if * match.test(layer[property]) evaluates to true, the layer will be * included in the array returned. If no layers are found, an empty * array is returned. * * Returns: * {Array()} A list of layers matching the given criteria. * An empty array is returned if no matches are found. */ getLayersBy: function(property, match) { return this.getBy("layers", property, match); }, /** * APIMethod: getLayersByName * Get a list of layers with names matching the given name. * * Parameter: * match - {String | Object} A layer name. The name can also be a regular * expression literal or object. In addition, it can be any object * with a method named test. For reqular expressions or other, if * name.test(layer.name) evaluates to true, the layer will be included * in the list of layers returned. If no layers are found, an empty * array is returned. * * Returns: * {Array()} A list of layers matching the given name. * An empty array is returned if no matches are found. */ getLayersByName: function(match) { return this.getLayersBy("name", match); }, /** * APIMethod: getLayersByClass * Get a list of layers of a given class (CLASS_NAME). * * Parameter: * match - {String | Object} A layer class name. The match can also be a * regular expression literal or object. In addition, it can be any * object with a method named test. For reqular expressions or other, * if type.test(layer.CLASS_NAME) evaluates to true, the layer will * be included in the list of layers returned. If no layers are * found, an empty array is returned. * * Returns: * {Array()} A list of layers matching the given class. * An empty array is returned if no matches are found. */ getLayersByClass: function(match) { return this.getLayersBy("CLASS_NAME", match); }, /** * APIMethod: getControlsBy * Get a list of controls with properties matching the given criteria. * * Parameter: * property - {String} A control property to be matched. * match - {String | Object} A string to match. Can also be a regular * expression literal or object. In addition, it can be any object * with a method named test. For reqular expressions or other, if * match.test(layer[property]) evaluates to true, the layer will be * included in the array returned. If no layers are found, an empty * array is returned. * * Returns: * {Array()} A list of controls matching the given * criteria. An empty array is returned if no matches are found. */ getControlsBy: function(property, match) { return this.getBy("controls", property, match); }, /** * APIMethod: getControlsByClass * Get a list of controls of a given class (CLASS_NAME). * * Parameter: * match - {String | Object} A control class name. The match can also be a * regular expression literal or object. In addition, it can be any * object with a method named test. For reqular expressions or other, * if type.test(control.CLASS_NAME) evaluates to true, the control will * be included in the list of controls returned. If no controls are * found, an empty array is returned. * * Returns: * {Array()} A list of controls matching the given class. * An empty array is returned if no matches are found. */ getControlsByClass: function(match) { return this.getControlsBy("CLASS_NAME", match); }, /********************************************************/ /* */ /* Layer Functions */ /* */ /* The following functions deal with adding and */ /* removing Layers to and from the Map */ /* */ /********************************************************/ /** * APIMethod: getLayer * Get a layer based on its id * * Parameter: * id - {String} A layer id * * Returns: * {} The Layer with the corresponding id from the map's * layer collection, or null if not found. */ getLayer: function(id) { var foundLayer = null; for (var i = 0; i < this.layers.length; i++) { var layer = this.layers[i]; if (layer.id == id) { foundLayer = layer; break; } } return foundLayer; }, /** * Method: setLayerZIndex * * Parameters: * layer - {} * zIdx - {int} */ setLayerZIndex: function (layer, zIdx) { layer.setZIndex( this.Z_INDEX_BASE[layer.isBaseLayer ? 'BaseLayer' : 'Overlay'] + zIdx * 5 ); }, /** * Method: resetLayersZIndex * Reset each layer's z-index based on layer's array index */ resetLayersZIndex: function() { for (var i = 0; i < this.layers.length; i++) { var layer = this.layers[i]; this.setLayerZIndex(layer, i); } }, /** * APIMethod: addLayer * * Parameters: * layer - {} */ addLayer: function (layer) { for(var i=0; i < this.layers.length; i++) { if (this.layers[i] == layer) { var msg = OpenLayers.i18n('layerAlreadyAdded', {'layerName':layer.name}); OpenLayers.Console.warn(msg); return false; } } this.events.triggerEvent("preaddlayer", {layer: layer}); layer.div.className = "olLayerDiv"; layer.div.style.overflow = ""; this.setLayerZIndex(layer, this.layers.length); if (layer.isFixed) { this.viewPortDiv.appendChild(layer.div); } else { this.layerContainerDiv.appendChild(layer.div); } this.layers.push(layer); layer.setMap(this); if (layer.isBaseLayer) { if (this.baseLayer == null) { // set the first baselaye we add as the baselayer this.setBaseLayer(layer); } else { layer.setVisibility(false); } } else { layer.redraw(); } this.events.triggerEvent("addlayer", {layer: layer}); }, /** * APIMethod: addLayers * * Parameters: * layers - {Array()} */ addLayers: function (layers) { for (var i = 0; i < layers.length; i++) { this.addLayer(layers[i]); } }, /** * APIMethod: removeLayer * Removes a layer from the map by removing its visual element (the * layer.div property), then removing it from the map's internal list * of layers, setting the layer's map property to null. * * a "removelayer" event is triggered. * * very worthy of mention is that simply removing a layer from a map * will not cause the removal of any popups which may have been created * by the layer. this is due to the fact that it was decided at some * point that popups would not belong to layers. thus there is no way * for us to know here to which layer the popup belongs. * * A simple solution to this is simply to call destroy() on the layer. * the default OpenLayers.Layer class's destroy() function * automatically takes care to remove itself from whatever map it has * been attached to. * * The correct solution is for the layer itself to register an * event-handler on "removelayer" and when it is called, if it * recognizes itself as the layer being removed, then it cycles through * its own personal list of popups, removing them from the map. * * Parameters: * layer - {} * setNewBaseLayer - {Boolean} Default is true */ removeLayer: function(layer, setNewBaseLayer) { if (setNewBaseLayer == null) { setNewBaseLayer = true; } if (layer.isFixed) { this.viewPortDiv.removeChild(layer.div); } else { this.layerContainerDiv.removeChild(layer.div); } OpenLayers.Util.removeItem(this.layers, layer); layer.removeMap(this); layer.map = null; // if we removed the base layer, need to set a new one if(this.baseLayer == layer) { this.baseLayer = null; if(setNewBaseLayer) { for(var i=0; i < this.layers.length; i++) { var iLayer = this.layers[i]; if (iLayer.isBaseLayer) { this.setBaseLayer(iLayer); break; } } } } this.resetLayersZIndex(); this.events.triggerEvent("removelayer", {layer: layer}); }, /** * APIMethod: getNumLayers * * Returns: * {Int} The number of layers attached to the map. */ getNumLayers: function () { return this.layers.length; }, /** * APIMethod: getLayerIndex * * Parameters: * layer - {} * * Returns: * {Integer} The current (zero-based) index of the given layer in the map's * layer stack. Returns -1 if the layer isn't on the map. */ getLayerIndex: function (layer) { return OpenLayers.Util.indexOf(this.layers, layer); }, /** * APIMethod: setLayerIndex * Move the given layer to the specified (zero-based) index in the layer * list, changing its z-index in the map display. Use * map.getLayerIndex() to find out the current index of a layer. Note * that this cannot (or at least should not) be effectively used to * raise base layers above overlays. * * Parameters: * layer - {} * idx - {int} */ setLayerIndex: function (layer, idx) { var base = this.getLayerIndex(layer); if (idx < 0) { idx = 0; } else if (idx > this.layers.length) { idx = this.layers.length; } if (base != idx) { this.layers.splice(base, 1); this.layers.splice(idx, 0, layer); for (var i = 0; i < this.layers.length; i++) { this.setLayerZIndex(this.layers[i], i); } this.events.triggerEvent("changelayer", { layer: layer, property: "order" }); } }, /** * APIMethod: raiseLayer * Change the index of the given layer by delta. If delta is positive, * the layer is moved up the map's layer stack; if delta is negative, * the layer is moved down. Again, note that this cannot (or at least * should not) be effectively used to raise base layers above overlays. * * Paremeters: * layer - {} * idx - {int} */ raiseLayer: function (layer, delta) { var idx = this.getLayerIndex(layer) + delta; this.setLayerIndex(layer, idx); }, /** * APIMethod: setBaseLayer * Allows user to specify one of the currently-loaded layers as the Map's * new base layer. * * Parameters: * newBaseLayer - {} */ setBaseLayer: function(newBaseLayer) { var oldExtent = null; if (this.baseLayer) { oldExtent = this.baseLayer.getExtent(); } if (newBaseLayer != this.baseLayer) { // is newBaseLayer an already loaded layer?m if (OpenLayers.Util.indexOf(this.layers, newBaseLayer) != -1) { // make the old base layer invisible if (this.baseLayer != null) { this.baseLayer.setVisibility(false); } // set new baselayer this.baseLayer = newBaseLayer; // Increment viewRequestID since the baseLayer is // changing. This is used by tiles to check if they should // draw themselves. this.viewRequestID++; this.baseLayer.visibility = true; //redraw all layers var center = this.getCenter(); if (center != null) { //either get the center from the old Extent or just from // the current center of the map. var newCenter = (oldExtent) ? oldExtent.getCenterLonLat() : center; //the new zoom will either come from the old Extent or // from the current resolution of the map var newZoom = (oldExtent) ? this.getZoomForExtent(oldExtent, true) : this.getZoomForResolution(this.resolution, true); // zoom and force zoom change this.setCenter(newCenter, newZoom, false, true); } this.events.triggerEvent("changebaselayer", { layer: this.baseLayer }); } } }, /********************************************************/ /* */ /* Control Functions */ /* */ /* The following functions deal with adding and */ /* removing Controls to and from the Map */ /* */ /********************************************************/ /** * APIMethod: addControl * * Parameters: * control - {} * px - {} */ addControl: function (control, px) { this.controls.push(control); this.addControlToMap(control, px); }, /** * Method: addControlToMap * * Parameters: * * control - {} * px - {} */ addControlToMap: function (control, px) { // If a control doesn't have a div at this point, it belongs in the // viewport. control.outsideViewport = (control.div != null); // If the map has a displayProjection, and the control doesn't, set // the display projection. if (this.displayProjection && !control.displayProjection) { control.displayProjection = this.displayProjection; } control.setMap(this); var div = control.draw(px); if (div) { if(!control.outsideViewport) { div.style.zIndex = this.Z_INDEX_BASE['Control'] + this.controls.length; this.viewPortDiv.appendChild( div ); } } }, /** * APIMethod: getControl * * Parameters: * id - {String} ID of the control to return. * * Returns: * {} The control from the map's list of controls * which has a matching 'id'. If none found, * returns null. */ getControl: function (id) { var returnControl = null; for(var i=0; i < this.controls.length; i++) { var control = this.controls[i]; if (control.id == id) { returnControl = control; break; } } return returnControl; }, /** * APIMethod: removeControl * Remove a control from the map. Removes the control both from the map * object's internal array of controls, as well as from the map's * viewPort (assuming the control was not added outsideViewport) * * Parameters: * control - {} The control to remove. */ removeControl: function (control) { //make sure control is non-null and actually part of our map if ( (control) && (control == this.getControl(control.id)) ) { if (control.div && (control.div.parentNode == this.viewPortDiv)) { this.viewPortDiv.removeChild(control.div); } OpenLayers.Util.removeItem(this.controls, control); } }, /********************************************************/ /* */ /* Popup Functions */ /* */ /* The following functions deal with adding and */ /* removing Popups to and from the Map */ /* */ /********************************************************/ /** * APIMethod: addPopup * * Parameters: * popup - {} * exclusive - {Boolean} If true, closes all other popups first */ addPopup: function(popup, exclusive) { if (exclusive) { //remove all other popups from screen for (var i = this.popups.length - 1; i >= 0; --i) { this.removePopup(this.popups[i]); } } popup.map = this; this.popups.push(popup); var popupDiv = popup.draw(); if (popupDiv) { popupDiv.style.zIndex = this.Z_INDEX_BASE['Popup'] + this.popups.length; this.layerContainerDiv.appendChild(popupDiv); } }, /** * APIMethod: removePopup * * Parameters: * popup - {} */ removePopup: function(popup) { OpenLayers.Util.removeItem(this.popups, popup); if (popup.div) { try { this.layerContainerDiv.removeChild(popup.div); } catch (e) { } // Popups sometimes apparently get disconnected // from the layerContainerDiv, and cause complaints. } popup.map = null; }, /********************************************************/ /* */ /* Container Div Functions */ /* */ /* The following functions deal with the access to */ /* and maintenance of the size of the container div */ /* */ /********************************************************/ /** * APIMethod: getSize * * Returns: * {} An object that represents the * size, in pixels, of the div into which OpenLayers * has been loaded. * Note - A clone() of this locally cached variable is * returned, so as not to allow users to modify it. */ getSize: function () { var size = null; if (this.size != null) { size = this.size.clone(); } return size; }, /** * APIMethod: updateSize * This function should be called by any external code which dynamically * changes the size of the map div (because mozilla wont let us catch * the "onresize" for an element) */ updateSize: function() { // the div might have moved on the page, also this.events.element.offsets = null; var newSize = this.getCurrentSize(); var oldSize = this.getSize(); if (oldSize == null) { this.size = oldSize = newSize; } if (!newSize.equals(oldSize)) { // store the new size this.size = newSize; //notify layers of mapresize for(var i=0; i < this.layers.length; i++) { this.layers[i].onMapResize(); } if (this.baseLayer != null) { var center = new OpenLayers.Pixel(newSize.w /2, newSize.h / 2); var centerLL = this.getLonLatFromViewPortPx(center); var zoom = this.getZoom(); this.zoom = null; this.setCenter(this.getCenter(), zoom); } } }, /** * Method: getCurrentSize * * Returns: * {} A new object with the dimensions * of the map div */ getCurrentSize: function() { var size = new OpenLayers.Size(this.div.clientWidth, this.div.clientHeight); // Workaround for the fact that hidden elements return 0 for size. if (size.w == 0 && size.h == 0 || isNaN(size.w) && isNaN(size.h)) { var dim = OpenLayers.Element.getDimensions(this.div); size.w = dim.width; size.h = dim.height; } if (size.w == 0 && size.h == 0 || isNaN(size.w) && isNaN(size.h)) { size.w = parseInt(this.div.style.width); size.h = parseInt(this.div.style.height); } return size; }, /** * Method: calculateBounds * * Parameters: * center - {} Default is this.getCenter() * resolution - {float} Default is this.getResolution() * * Returns: * {} A bounds based on resolution, center, and * current mapsize. */ calculateBounds: function(center, resolution) { var extent = null; if (center == null) { center = this.getCenter(); } if (resolution == null) { resolution = this.getResolution(); } if ((center != null) && (resolution != null)) { var size = this.getSize(); var w_deg = size.w * resolution; var h_deg = size.h * resolution; extent = new OpenLayers.Bounds(center.lon - w_deg / 2, center.lat - h_deg / 2, center.lon + w_deg / 2, center.lat + h_deg / 2); } return extent; }, /********************************************************/ /* */ /* Zoom, Center, Pan Functions */ /* */ /* The following functions handle the validation, */ /* getting and setting of the Zoom Level and Center */ /* as well as the panning of the Map */ /* */ /********************************************************/ /** * APIMethod: getCenter * * Returns: * {} */ getCenter: function () { return this.center; }, /** * APIMethod: getZoom * * Returns: * {Integer} */ getZoom: function () { return this.zoom; }, /** * APIMethod: pan * Allows user to pan by a value of screen pixels * * Parameters: * dx - {Integer} * dy - {Integer} * options - {Object} Options to configure panning: * - *animate* {Boolean} Use panTo instead of setCenter. Default is true. * - *dragging* {Boolean} Call setCenter with dragging true. Default is * false. */ pan: function(dx, dy, options) { // this should be pushed to applyDefaults and extend if (!options) { options = {}; } OpenLayers.Util.applyDefaults(options, { animate: true, dragging: false }); // getCenter var centerPx = this.getViewPortPxFromLonLat(this.getCenter()); // adjust var newCenterPx = centerPx.add(dx, dy); // only call setCenter if not dragging or there has been a change if (!options.dragging || !newCenterPx.equals(centerPx)) { var newCenterLonLat = this.getLonLatFromViewPortPx(newCenterPx); if (options.animate) { this.panTo(newCenterLonLat); } else { this.setCenter(newCenterLonLat, null, options.dragging); } } }, /** * APIMethod: panTo * Allows user to pan to a new lonlat * If the new lonlat is in the current extent the map will slide smoothly * * Parameters: * lonlat - {} */ panTo: function(lonlat) { if (this.panMethod && this.getExtent().containsLonLat(lonlat)) { if (!this.panTween) { this.panTween = new OpenLayers.Tween(this.panMethod); } var center = this.getCenter(); var from = { lon: center.lon, lat: center.lat }; var to = { lon: lonlat.lon, lat: lonlat.lat }; this.panTween.start(from, to, 50, { callbacks: { start: OpenLayers.Function.bind(function(lonlat) { this.events.triggerEvent("movestart"); }, this), eachStep: OpenLayers.Function.bind(function(lonlat) { lonlat = new OpenLayers.LonLat(lonlat.lon, lonlat.lat); this.moveTo(lonlat, this.zoom, { 'dragging': true, 'noEvent': true }); }, this), done: OpenLayers.Function.bind(function(lonlat) { lonlat = new OpenLayers.LonLat(lonlat.lon, lonlat.lat); this.moveTo(lonlat, this.zoom, { 'noEvent': true }); this.events.triggerEvent("moveend"); }, this) } }); } else { this.setCenter(lonlat); } }, /** * APIMethod: setCenter * * Parameters: * lonlat - {} * zoom - {Integer} * dragging - {Boolean} Specifies whether or not to trigger * movestart/end events * forceZoomChange - {Boolean} Specifies whether or not to trigger zoom * change events (needed on baseLayer change) * * TBD: reconsider forceZoomChange in 3.0 */ setCenter: function(lonlat, zoom, dragging, forceZoomChange) { this.moveTo(lonlat, zoom, { 'dragging': dragging, 'forceZoomChange': forceZoomChange, 'caller': 'setCenter' }); }, /** * Method: moveTo * * Parameters: * lonlat - {} * zoom - {Integer} * options - {Object} */ moveTo: function(lonlat, zoom, options) { if (!options) { options = {}; } // dragging is false by default var dragging = options.dragging; // forceZoomChange is false by default var forceZoomChange = options.forceZoomChange; // noEvent is false by default var noEvent = options.noEvent; if (this.panTween && options.caller == "setCenter") { this.panTween.stop(); } if (!this.center && !this.isValidLonLat(lonlat)) { lonlat = this.maxExtent.getCenterLonLat(); } if(this.restrictedExtent != null) { // In 3.0, decide if we want to change interpretation of maxExtent. if(lonlat == null) { lonlat = this.getCenter(); } if(zoom == null) { zoom = this.getZoom(); } var resolution = this.getResolutionForZoom(zoom); var extent = this.calculateBounds(lonlat, resolution); if(!this.restrictedExtent.containsBounds(extent)) { var maxCenter = this.restrictedExtent.getCenterLonLat(); if(extent.getWidth() > this.restrictedExtent.getWidth()) { lonlat = new OpenLayers.LonLat(maxCenter.lon, lonlat.lat); } else if(extent.left < this.restrictedExtent.left) { lonlat = lonlat.add(this.restrictedExtent.left - extent.left, 0); } else if(extent.right > this.restrictedExtent.right) { lonlat = lonlat.add(this.restrictedExtent.right - extent.right, 0); } if(extent.getHeight() > this.restrictedExtent.getHeight()) { lonlat = new OpenLayers.LonLat(lonlat.lon, maxCenter.lat); } else if(extent.bottom < this.restrictedExtent.bottom) { lonlat = lonlat.add(0, this.restrictedExtent.bottom - extent.bottom); } else if(extent.top > this.restrictedExtent.top) { lonlat = lonlat.add(0, this.restrictedExtent.top - extent.top); } } } var zoomChanged = forceZoomChange || ( (this.isValidZoomLevel(zoom)) && (zoom != this.getZoom()) ); var centerChanged = (this.isValidLonLat(lonlat)) && (!lonlat.equals(this.center)); // if neither center nor zoom will change, no need to do anything if (zoomChanged || centerChanged || !dragging) { if (!this.dragging && !noEvent) { this.events.triggerEvent("movestart"); } if (centerChanged) { if ((!zoomChanged) && (this.center)) { // if zoom hasnt changed, just slide layerContainer // (must be done before setting this.center to new value) this.centerLayerContainer(lonlat); } this.center = lonlat.clone(); } // (re)set the layerContainerDiv's location if ((zoomChanged) || (this.layerContainerOrigin == null)) { this.layerContainerOrigin = this.center.clone(); this.layerContainerDiv.style.left = "0px"; this.layerContainerDiv.style.top = "0px"; } if (zoomChanged) { this.zoom = zoom; this.resolution = this.getResolutionForZoom(zoom); // zoom level has changed, increment viewRequestID. this.viewRequestID++; } var bounds = this.getExtent(); //send the move call to the baselayer and all the overlays this.baseLayer.moveTo(bounds, zoomChanged, dragging); bounds = this.baseLayer.getExtent(); for (var i = 0; i < this.layers.length; i++) { var layer = this.layers[i]; if (!layer.isBaseLayer) { var inRange = layer.calculateInRange(); if (layer.inRange != inRange) { // the inRange property has changed. If the layer is // no longer in range, we turn it off right away. If // the layer is no longer out of range, the moveTo // call below will turn on the layer. layer.inRange = inRange; if (!inRange) { layer.display(false); } this.events.triggerEvent("changelayer", { layer: layer, property: "visibility" }); } if (inRange && layer.visibility) { layer.moveTo(bounds, zoomChanged, dragging); } } } if (zoomChanged) { //redraw popups for (var i = 0; i < this.popups.length; i++) { this.popups[i].updatePosition(); } } this.events.triggerEvent("move"); if (zoomChanged) { this.events.triggerEvent("zoomend"); } } // even if nothing was done, we want to notify of this if (!dragging && !noEvent) { this.events.triggerEvent("moveend"); } // Store the map dragging state for later use this.dragging = !!dragging; }, /** * Method: centerLayerContainer * This function takes care to recenter the layerContainerDiv. * * Parameters: * lonlat - {} */ centerLayerContainer: function (lonlat) { var originPx = this.getViewPortPxFromLonLat(this.layerContainerOrigin); var newPx = this.getViewPortPxFromLonLat(lonlat); if ((originPx != null) && (newPx != null)) { this.layerContainerDiv.style.left = Math.round(originPx.x - newPx.x) + "px"; this.layerContainerDiv.style.top = Math.round(originPx.y - newPx.y) + "px"; } }, /** * Method: isValidZoomLevel * * Parameters: * zoomLevel - {Integer} * * Returns: * {Boolean} Whether or not the zoom level passed in is non-null and * within the min/max range of zoom levels. */ isValidZoomLevel: function(zoomLevel) { return ( (zoomLevel != null) && (zoomLevel >= 0) && (zoomLevel < this.getNumZoomLevels()) ); }, /** * Method: isValidLonLat * * Parameters: * lonlat - {} * * Returns: * {Boolean} Whether or not the lonlat passed in is non-null and within * the maxExtent bounds */ isValidLonLat: function(lonlat) { var valid = false; if (lonlat != null) { var maxExtent = this.getMaxExtent(); valid = maxExtent.containsLonLat(lonlat); } return valid; }, /********************************************************/ /* */ /* Layer Options */ /* */ /* Accessor functions to Layer Options parameters */ /* */ /********************************************************/ /** * APIMethod: getProjection * This method returns a string representing the projection. In * the case of projection support, this will be the srsCode which * is loaded -- otherwise it will simply be the string value that * was passed to the projection at startup. * * FIXME: In 3.0, we will remove getProjectionObject, and instead * return a Projection object from this function. * * Returns: * {String} The Projection string from the base layer or null. */ getProjection: function() { var projection = this.getProjectionObject(); return projection ? projection.getCode() : null; }, /** * APIMethod: getProjectionObject * Returns the projection obect from the baselayer. * * Returns: * {} The Projection of the base layer. */ getProjectionObject: function() { var projection = null; if (this.baseLayer != null) { projection = this.baseLayer.projection; } return projection; }, /** * APIMethod: getMaxResolution * * Returns: * {String} The Map's Maximum Resolution */ getMaxResolution: function() { var maxResolution = null; if (this.baseLayer != null) { maxResolution = this.baseLayer.maxResolution; } return maxResolution; }, /** * APIMethod: getMaxExtent * * Returns: * {} */ getMaxExtent: function () { var maxExtent = null; if (this.baseLayer != null) { maxExtent = this.baseLayer.maxExtent; } return maxExtent; }, /** * APIMethod: getNumZoomLevels * * Returns: * {Integer} The total number of zoom levels that can be displayed by the * current baseLayer. */ getNumZoomLevels: function() { var numZoomLevels = null; if (this.baseLayer != null) { numZoomLevels = this.baseLayer.numZoomLevels; } return numZoomLevels; }, /********************************************************/ /* */ /* Baselayer Functions */ /* */ /* The following functions, all publicly exposed */ /* in the API?, are all merely wrappers to the */ /* the same calls on whatever layer is set as */ /* the current base layer */ /* */ /********************************************************/ /** * APIMethod: getExtent * * Returns: * {} A Bounds object which represents the lon/lat * bounds of the current viewPort. * If no baselayer is set, returns null. */ getExtent: function () { var extent = null; if (this.baseLayer != null) { extent = this.baseLayer.getExtent(); } return extent; }, /** * APIMethod: getResolution * * Returns: * {Float} The current resolution of the map. * If no baselayer is set, returns null. */ getResolution: function () { var resolution = null; if (this.baseLayer != null) { resolution = this.baseLayer.getResolution(); } return resolution; }, /** * APIMethod: getScale * * Returns: * {Float} The current scale denominator of the map. * If no baselayer is set, returns null. */ getScale: function () { var scale = null; if (this.baseLayer != null) { var res = this.getResolution(); var units = this.baseLayer.units; scale = OpenLayers.Util.getScaleFromResolution(res, units); } return scale; }, /** * APIMethod: getZoomForExtent * * Parameters: * bounds - {} * closest - {Boolean} Find the zoom level that most closely fits the * specified bounds. Note that this may result in a zoom that does * not exactly contain the entire extent. * Default is false. * * Returns: * {Integer} A suitable zoom level for the specified bounds. * If no baselayer is set, returns null. */ getZoomForExtent: function (bounds, closest) { var zoom = null; if (this.baseLayer != null) { zoom = this.baseLayer.getZoomForExtent(bounds, closest); } return zoom; }, /** * APIMethod: getResolutionForZoom * * Parameter: * zoom - {Float} * * Returns: * {Float} A suitable resolution for the specified zoom. If no baselayer * is set, returns null. */ getResolutionForZoom: function(zoom) { var resolution = null; if(this.baseLayer) { resolution = this.baseLayer.getResolutionForZoom(zoom); } return resolution; }, /** * APIMethod: getZoomForResolution * * Parameter: * resolution - {Float} * closest - {Boolean} Find the zoom level that corresponds to the absolute * closest resolution, which may result in a zoom whose corresponding * resolution is actually smaller than we would have desired (if this * is being called from a getZoomForExtent() call, then this means that * the returned zoom index might not actually contain the entire * extent specified... but it'll be close). * Default is false. * * Returns: * {Integer} A suitable zoom level for the specified resolution. * If no baselayer is set, returns null. */ getZoomForResolution: function(resolution, closest) { var zoom = null; if (this.baseLayer != null) { zoom = this.baseLayer.getZoomForResolution(resolution, closest); } return zoom; }, /********************************************************/ /* */ /* Zooming Functions */ /* */ /* The following functions, all publicly exposed */ /* in the API, are all merely wrappers to the */ /* the setCenter() function */ /* */ /********************************************************/ /** * APIMethod: zoomTo * Zoom to a specific zoom level * * Parameters: * zoom - {Integer} */ zoomTo: function(zoom) { if (this.isValidZoomLevel(zoom)) { this.setCenter(null, zoom); } }, /** * APIMethod: zoomIn * * Parameters: * zoom - {int} */ zoomIn: function() { this.zoomTo(this.getZoom() + 1); }, /** * APIMethod: zoomOut * * Parameters: * zoom - {int} */ zoomOut: function() { this.zoomTo(this.getZoom() - 1); }, /** * APIMethod: zoomToExtent * Zoom to the passed in bounds, recenter * * Parameters: * bounds - {} */ zoomToExtent: function(bounds) { var center = bounds.getCenterLonLat(); if (this.baseLayer.wrapDateLine) { var maxExtent = this.getMaxExtent(); //fix straddling bounds (in the case of a bbox that straddles the // dateline, it's left and right boundaries will appear backwards. // we fix this by allowing a right value that is greater than the // max value at the dateline -- this allows us to pass a valid // bounds to calculate zoom) // bounds = bounds.clone(); while (bounds.right < bounds.left) { bounds.right += maxExtent.getWidth(); } //if the bounds was straddling (see above), then the center point // we got from it was wrong. So we take our new bounds and ask it // for the center. Because our new bounds is at least partially // outside the bounds of maxExtent, the new calculated center // might also be. We don't want to pass a bad center value to // setCenter, so we have it wrap itself across the date line. // center = bounds.getCenterLonLat().wrapDateLine(maxExtent); } this.setCenter(center, this.getZoomForExtent(bounds)); }, /** * APIMethod: zoomToMaxExtent * Zoom to the full extent and recenter. */ zoomToMaxExtent: function() { this.zoomToExtent(this.getMaxExtent()); }, /** * APIMethod: zoomToScale * Zoom to a specified scale * * Parameters: * scale - {float} */ zoomToScale: function(scale) { var res = OpenLayers.Util.getResolutionFromScale(scale, this.baseLayer.units); var size = this.getSize(); var w_deg = size.w * res; var h_deg = size.h * res; var center = this.getCenter(); var extent = new OpenLayers.Bounds(center.lon - w_deg / 2, center.lat - h_deg / 2, center.lon + w_deg / 2, center.lat + h_deg / 2); this.zoomToExtent(extent); }, /********************************************************/ /* */ /* Translation Functions */ /* */ /* The following functions translate between */ /* LonLat, LayerPx, and ViewPortPx */ /* */ /********************************************************/ // // TRANSLATION: LonLat <-> ViewPortPx // /** * Method: getLonLatFromViewPortPx * * Parameters: * viewPortPx - {} * * Returns: * {} An OpenLayers.LonLat which is the passed-in view * port , translated into lon/lat * by the current base layer. */ getLonLatFromViewPortPx: function (viewPortPx) { var lonlat = null; if (this.baseLayer != null) { lonlat = this.baseLayer.getLonLatFromViewPortPx(viewPortPx); } return lonlat; }, /** * APIMethod: getViewPortPxFromLonLat * * Parameters: * lonlat - {} * * Returns: * {} An OpenLayers.Pixel which is the passed-in * , translated into view port * pixels by the current base layer. */ getViewPortPxFromLonLat: function (lonlat) { var px = null; if (this.baseLayer != null) { px = this.baseLayer.getViewPortPxFromLonLat(lonlat); } return px; }, // // CONVENIENCE TRANSLATION FUNCTIONS FOR API // /** * APIMethod: getLonLatFromPixel * * Parameters: * px - {} * * Returns: * {} An OpenLayers.LonLat corresponding to the given * OpenLayers.Pixel, translated into lon/lat by the * current base layer */ getLonLatFromPixel: function (px) { return this.getLonLatFromViewPortPx(px); }, /** * APIMethod: getPixelFromLonLat * Returns a pixel location given a map location. The map location is * translated to an integer pixel location (in viewport pixel * coordinates) by the current base layer. * * Parameters: * lonlat - {} A map location. * * Returns: * {} An OpenLayers.Pixel corresponding to the * translated into view port pixels by the current * base layer. */ getPixelFromLonLat: function (lonlat) { var px = this.getViewPortPxFromLonLat(lonlat); px.x = Math.round(px.x); px.y = Math.round(px.y); return px; }, // // TRANSLATION: ViewPortPx <-> LayerPx // /** * APIMethod: getViewPortPxFromLayerPx * * Parameters: * layerPx - {} * * Returns: * {} Layer Pixel translated into ViewPort Pixel * coordinates */ getViewPortPxFromLayerPx:function(layerPx) { var viewPortPx = null; if (layerPx != null) { var dX = parseInt(this.layerContainerDiv.style.left); var dY = parseInt(this.layerContainerDiv.style.top); viewPortPx = layerPx.add(dX, dY); } return viewPortPx; }, /** * APIMethod: getLayerPxFromViewPortPx * * Parameters: * viewPortPx - {} * * Returns: * {} ViewPort Pixel translated into Layer Pixel * coordinates */ getLayerPxFromViewPortPx:function(viewPortPx) { var layerPx = null; if (viewPortPx != null) { var dX = -parseInt(this.layerContainerDiv.style.left); var dY = -parseInt(this.layerContainerDiv.style.top); layerPx = viewPortPx.add(dX, dY); if (isNaN(layerPx.x) || isNaN(layerPx.y)) { layerPx = null; } } return layerPx; }, // // TRANSLATION: LonLat <-> LayerPx // /** * Method: getLonLatFromLayerPx * * Parameters: * px - {} * * Returns: * {} */ getLonLatFromLayerPx: function (px) { //adjust for displacement of layerContainerDiv px = this.getViewPortPxFromLayerPx(px); return this.getLonLatFromViewPortPx(px); }, /** * APIMethod: getLayerPxFromLonLat * * Parameters: * lonlat - {} lonlat * * Returns: * {} An OpenLayers.Pixel which is the passed-in * , translated into layer pixels * by the current base layer */ getLayerPxFromLonLat: function (lonlat) { //adjust for displacement of layerContainerDiv var px = this.getPixelFromLonLat(lonlat); return this.getLayerPxFromViewPortPx(px); }, CLASS_NAME: "OpenLayers.Map" }); /** * Constant: TILE_WIDTH * {Integer} 256 Default tile width (unless otherwise specified) */ OpenLayers.Map.TILE_WIDTH = 256; /** * Constant: TILE_HEIGHT * {Integer} 256 Default tile height (unless otherwise specified) */ OpenLayers.Map.TILE_HEIGHT = 256; /* ====================================================================== OpenLayers/Marker.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Events.js * @requires OpenLayers/Icon.js */ /** * Class: OpenLayers.Marker * Instances of OpenLayers.Marker are a combination of a * and an . * * Markers are generally added to a special layer called * . * * Example: * (code) * var markers = new OpenLayers.Layer.Markers( "Markers" ); * map.addLayer(markers); * * var size = new OpenLayers.Size(10,17); * var offset = new OpenLayers.Pixel(-(size.w/2), -size.h); * var icon = new OpenLayers.Icon('http://boston.openguides.org/markers/AQUA.png',size,offset); * markers.addMarker(new OpenLayers.Marker(new OpenLayers.LonLat(0,0),icon)); * markers.addMarker(new OpenLayers.Marker(new OpenLayers.LonLat(0,0),icon.clone())); * * (end) * * Note that if you pass an icon into the Marker constructor, it will take * that icon and use it. This means that you should not share icons between * markers -- you use them once, but you should clone() for any additional * markers using that same icon. */ OpenLayers.Marker = OpenLayers.Class({ /** * Property: icon * {} The icon used by this marker. */ icon: null, /** * Property: lonlat * {} location of object */ lonlat: null, /** * Property: events * {} the event handler. */ events: null, /** * Property: map * {} the map this marker is attached to */ map: null, /** * Constructor: OpenLayers.Marker * Paraemeters: * icon - {} the icon for this marker * lonlat - {} the position of this marker */ initialize: function(lonlat, icon) { this.lonlat = lonlat; var newIcon = (icon) ? icon : OpenLayers.Marker.defaultIcon(); if (this.icon == null) { this.icon = newIcon; } else { this.icon.url = newIcon.url; this.icon.size = newIcon.size; this.icon.offset = newIcon.offset; this.icon.calculateOffset = newIcon.calculateOffset; } this.events = new OpenLayers.Events(this, this.icon.imageDiv, null); }, /** * APIMethod: destroy * Destroy the marker. You must first remove the marker from any * layer which it has been added to, or you will get buggy behavior. * (This can not be done within the marker since the marker does not * know which layer it is attached to.) */ destroy: function() { this.map = null; this.events.destroy(); this.events = null; if (this.icon != null) { this.icon.destroy(); this.icon = null; } }, /** * Method: draw * Calls draw on the icon, and returns that output. * * Parameters: * px - {} * * Returns: * {DOMElement} A new DOM Image with this marker's icon set at the * location passed-in */ draw: function(px) { return this.icon.draw(px); }, /** * Method: moveTo * Move the marker to the new location. * * Parameters: * px - {} the pixel position to move to */ moveTo: function (px) { if ((px != null) && (this.icon != null)) { this.icon.moveTo(px); } this.lonlat = this.map.getLonLatFromLayerPx(px); }, /** * Method: onScreen * * Returns: * {Boolean} Whether or not the marker is currently visible on screen. */ onScreen:function() { var onScreen = false; if (this.map) { var screenBounds = this.map.getExtent(); onScreen = screenBounds.containsLonLat(this.lonlat); } return onScreen; }, /** * Method: inflate * Englarges the markers icon by the specified ratio. * * Parameters: * inflate - {float} the ratio to enlarge the marker by (passing 2 * will double the size). */ inflate: function(inflate) { if (this.icon) { var newSize = new OpenLayers.Size(this.icon.size.w * inflate, this.icon.size.h * inflate); this.icon.setSize(newSize); } }, /** * Method: setOpacity * Change the opacity of the marker by changin the opacity of * its icon * * Parameters: * opacity - {float} Specified as fraction (0.4, etc) */ setOpacity: function(opacity) { this.icon.setOpacity(opacity); }, /** * Method: setUrl * Change URL of the Icon Image. * * url - {String} */ setUrl: function(url) { this.icon.setUrl(url); }, /** * Method: display * Hide or show the icon * * display - {Boolean} */ display: function(display) { this.icon.display(display); }, CLASS_NAME: "OpenLayers.Marker" }); /** * Function: defaultIcon * Creates a default . * * Returns: * {} A default OpenLayers.Icon to use for a marker */ OpenLayers.Marker.defaultIcon = function() { var url = OpenLayers.Util.getImagesLocation() + "marker.png"; var size = new OpenLayers.Size(21, 25); var calculateOffset = function(size) { return new OpenLayers.Pixel(-(size.w/2), -size.h); }; return new OpenLayers.Icon(url, size, null, calculateOffset); }; /* ====================================================================== OpenLayers/Popup/AnchoredBubble.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Popup/Anchored.js */ /** * Class: OpenLayers.Popup.AnchoredBubble * * Inherits from: * - */ OpenLayers.Popup.AnchoredBubble = OpenLayers.Class(OpenLayers.Popup.Anchored, { /** * Property: rounded * {Boolean} Has the popup been rounded yet? */ rounded: false, /** * Constructor: OpenLayers.Popup.AnchoredBubble * * Parameters: * id - {String} * lonlat - {} * size - {} * contentHTML - {String} * anchor - {Object} Object to which we'll anchor the popup. Must expose * a 'size' () and 'offset' () * (Note that this is generally an ). * closeBox - {Boolean} * closeBoxCallback - {Function} Function to be called on closeBox click. */ initialize:function(id, lonlat, size, contentHTML, anchor, closeBox, closeBoxCallback) { this.padding = new OpenLayers.Bounds( 0, OpenLayers.Popup.AnchoredBubble.CORNER_SIZE, 0, OpenLayers.Popup.AnchoredBubble.CORNER_SIZE ); OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments); }, /** * Method: draw * * Parameters: * px - {} * * Returns: * {DOMElement} Reference to a div that contains the drawn popup. */ draw: function(px) { OpenLayers.Popup.Anchored.prototype.draw.apply(this, arguments); this.setContentHTML(); //set the popup color and opacity this.setBackgroundColor(); this.setOpacity(); return this.div; }, /** * Method: updateRelativePosition * The popup has been moved to a new relative location, in which case * we will want to re-do the rico corners. */ updateRelativePosition: function() { this.setRicoCorners(); }, /** * APIMethod: setSize * * Parameters: * size - {} */ setSize:function(size) { OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments); this.setRicoCorners(); }, /** * APIMethod: setBackgroundColor * * Parameters: * color - {String} */ setBackgroundColor:function(color) { if (color != undefined) { this.backgroundColor = color; } if (this.div != null) { if (this.contentDiv != null) { this.div.style.background = "transparent"; OpenLayers.Rico.Corner.changeColor(this.groupDiv, this.backgroundColor); } } }, /** * APIMethod: setOpacity * * Parameters: * opacity - {float} */ setOpacity:function(opacity) { OpenLayers.Popup.Anchored.prototype.setOpacity.call(this, opacity); if (this.div != null) { if (this.groupDiv != null) { OpenLayers.Rico.Corner.changeOpacity(this.groupDiv, this.opacity); } } }, /** * Method: setBorder * Always sets border to 0. Bubble Popups can not have a border. * * Parameters: * border - {Integer} */ setBorder:function(border) { this.border = 0; }, /** * Method: setRicoCorners * Update RICO corners according to the popup's current relative postion. */ setRicoCorners:function() { var corners = this.getCornersToRound(this.relativePosition); var options = {corners: corners, color: this.backgroundColor, bgColor: "transparent", blend: false}; if (!this.rounded) { OpenLayers.Rico.Corner.round(this.div, options); this.rounded = true; } else { OpenLayers.Rico.Corner.reRound(this.groupDiv, options); //set the popup color and opacity this.setBackgroundColor(); this.setOpacity(); } }, /** * Method: getCornersToRound * * Returns: * {String} The proper corners string ("tr tl bl br") for rico to round. */ getCornersToRound:function() { var corners = ['tl', 'tr', 'bl', 'br']; //we want to round all the corners _except_ the opposite one. var corner = OpenLayers.Bounds.oppositeQuadrant(this.relativePosition); OpenLayers.Util.removeItem(corners, corner); return corners.join(" "); }, CLASS_NAME: "OpenLayers.Popup.AnchoredBubble" }); /** * Constant: CORNER_SIZE * {Integer} 5. Border space for the RICO corners. */ OpenLayers.Popup.AnchoredBubble.CORNER_SIZE = 5; /* ====================================================================== OpenLayers/Popup/Framed.js ====================================================================== */ /* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the * full text of the license. */ /** * @requires OpenLayers/Popup/Anchored.js */ /** * Class: OpenLayers.Popup.Framed * * Inherits from: * - */ OpenLayers.Popup.Framed = OpenLayers.Class(OpenLayers.Popup.Anchored, { /** * Property: imageSrc * {String} location of the image to be used as the popup frame */ imageSrc: null, /** * Property: imageSize * {} Size (measured in pixels) of the image located * by the 'imageSrc' property. */ imageSize: null, /** * APIProperty: isAlphaImage * {Boolean} The image has some alpha and thus needs to use the alpha * image hack. Note that setting this to true will have no noticeable * effect in FF or IE7 browsers, but will all but crush the ie6 * browser. * Default is false. */ isAlphaImage: false, /** * Property: positionBlocks * {Object} Hash of different position blocks (Object/Hashs). Each block * will be keyed by a two-character 'relativePosition' * code string (ie "tl", "tr", "bl", "br"). Block properties are * 'offset', 'padding' (self-explanatory), and finally the 'blocks' * parameter, which is an array of the block objects. * * Each block object must have 'size', 'anchor', and 'position' * properties. * * Note that positionBlocks should never be modified at runtime. */ positionBlocks: null, /** * Property: blocks * {Array[Object]} Array of objects, each of which is one "block" of the * popup. Each block has a 'div' and an 'image' property, both of * which are DOMElements, and the latter of which is appended to the * former. These are reused as the popup goes changing positions for * great economy and elegance. */ blocks: null, /** * APIProperty: fixedRelativePosition * {Boolean} We want the framed popup to work dynamically placed relative * to its anchor but also in just one fixed position. A well designed * framed popup will have the pixels and logic to display itself in * any of the four relative positions, but (understandably), this will * not be the case for all of them. By setting this property to 'true', * framed popup will not recalculate for the best placement each time * it's open, but will always open the same way. * Note that if this is set to true, it is generally advisable to also * set the 'panIntoView' property to true so that the popup can be * scrolled into view (since it will often be offscreen on open) * Default is false. */ fixedRelativePosition: false, /** * Constructor: OpenLayers.Popup.Framed * * Parameters: * id - {String} * lonlat - {} * size - {} * contentHTML - {String} * anchor - {Object} Object to which we'll anchor the popup. Must expose * a 'size' () and 'offset' () * (Note that this is generally an ). * closeBox - {Boolean} * closeBoxCallback - {Function} Function to be called on closeBox click. */ initialize:function(id, lonlat, size, contentHTML, anchor, closeBox, closeBoxCallback) { OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments); if (this.fixedRelativePosition) { //based on our decided relativePostion, set the current padding // this keeps us from getting into trouble this.updateRelativePosition(); //make calculateRelativePosition always returnt the specified // fiexed position. this.calculateRelativePosition = function(px) { return this.relativePosition; }; } this.contentDiv.style.position = "absolute"; this.contentDiv.style.zIndex = 1; if (closeBox) { this.closeDiv.style.zIndex = 1; } this.groupDiv.style.position = "absolute"; this.groupDiv.style.top = "0px"; this.groupDiv.style.left = "0px"; this.groupDiv.style.height = "100%"; this.groupDiv.style.width = "100%"; }, /** * APIMethod